21 #include "../../SDL_internal.h" 26 #if SDL_VIDEO_RENDER_D3D && !SDL_RENDER_DISABLED 28 #include "../../core/windows/SDL_windows.h" 33 #include "../SDL_sysrender.h" 34 #include "../SDL_d3dmath.h" 35 #include "../../video/windows/SDL_windowsvideo.h" 37 #if SDL_VIDEO_RENDER_D3D 38 #define D3D_DEBUG_INFO 43 #ifdef ASSEMBLE_SHADER 44 #pragma comment(lib, "d3dx9.lib") 58 typedef interface ID3DXBuffer ID3DXBuffer;
59 typedef interface ID3DXBuffer *LPD3DXBUFFER;
62 DEFINE_GUID(IID_ID3DXBuffer,
63 0x8ba5fb08, 0x5195, 0x40e2, 0xac, 0x58, 0xd, 0x98, 0x9c, 0x3a, 0
x1, 0
x2);
66 #define INTERFACE ID3DXBuffer 68 typedef interface ID3DXBuffer {
69 const struct ID3DXBufferVtbl
FAR* lpVtbl;
71 typedef const struct ID3DXBufferVtbl ID3DXBufferVtbl;
72 const struct ID3DXBufferVtbl
75 STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
76 STDMETHOD_(ULONG, AddRef)(THIS) PURE;
77 STDMETHOD_(ULONG, Release)(THIS) PURE;
80 STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;
81 STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;
88 CONST LPVOID* pDefines,
91 LPD3DXBUFFER* ppShader,
92 LPD3DXBUFFER* ppErrorMsgs);
94 static void PrintShaderData(LPDWORD shader_data, DWORD shader_size)
96 OutputDebugStringA(
"const DWORD shader_data[] = {\n\t");
100 for (i = 0; i < shader_size /
sizeof(DWORD); ++
i) {
107 OutputDebugStringA(
",\n ");
110 OutputDebugStringA(
", ");
113 SDL_snprintf(dword,
sizeof(dword),
"0x%8.8x", shader_data[i]);
114 OutputDebugStringA(dword);
116 OutputDebugStringA(
"\n};\n");
136 const Uint8 *Yplane,
int Ypitch,
137 const Uint8 *Uplane,
int Upitch,
138 const Uint8 *Vplane,
int Vpitch);
183 D3DPRESENT_PARAMETERS pparams;
187 D3DTEXTUREFILTERTYPE scaleMode[8];
188 IDirect3DSurface9 *defaultRenderTarget;
189 IDirect3DSurface9 *currentRenderTarget;
191 LPDIRECT3DPIXELSHADER9 ps_yuv;
201 IDirect3DTexture9 *staging;
207 D3DTEXTUREFILTERTYPE scaleMode;
211 D3D_TextureRep utexture;
212 D3D_TextureRep vtexture;
226 D3D_SetError(
const char *prefix, HRESULT
result)
231 case D3DERR_WRONGTEXTUREFORMAT:
232 error =
"WRONGTEXTUREFORMAT";
234 case D3DERR_UNSUPPORTEDCOLOROPERATION:
235 error =
"UNSUPPORTEDCOLOROPERATION";
237 case D3DERR_UNSUPPORTEDCOLORARG:
238 error =
"UNSUPPORTEDCOLORARG";
240 case D3DERR_UNSUPPORTEDALPHAOPERATION:
241 error =
"UNSUPPORTEDALPHAOPERATION";
243 case D3DERR_UNSUPPORTEDALPHAARG:
244 error =
"UNSUPPORTEDALPHAARG";
246 case D3DERR_TOOMANYOPERATIONS:
247 error =
"TOOMANYOPERATIONS";
249 case D3DERR_CONFLICTINGTEXTUREFILTER:
250 error =
"CONFLICTINGTEXTUREFILTER";
252 case D3DERR_UNSUPPORTEDFACTORVALUE:
253 error =
"UNSUPPORTEDFACTORVALUE";
255 case D3DERR_CONFLICTINGRENDERSTATE:
256 error =
"CONFLICTINGRENDERSTATE";
258 case D3DERR_UNSUPPORTEDTEXTUREFILTER:
259 error =
"UNSUPPORTEDTEXTUREFILTER";
261 case D3DERR_CONFLICTINGTEXTUREPALETTE:
262 error =
"CONFLICTINGTEXTUREPALETTE";
264 case D3DERR_DRIVERINTERNALERROR:
265 error =
"DRIVERINTERNALERROR";
267 case D3DERR_NOTFOUND:
270 case D3DERR_MOREDATA:
273 case D3DERR_DEVICELOST:
274 error =
"DEVICELOST";
276 case D3DERR_DEVICENOTRESET:
277 error =
"DEVICENOTRESET";
279 case D3DERR_NOTAVAILABLE:
280 error =
"NOTAVAILABLE";
282 case D3DERR_OUTOFVIDEOMEMORY:
283 error =
"OUTOFVIDEOMEMORY";
285 case D3DERR_INVALIDDEVICE:
286 error =
"INVALIDDEVICE";
288 case D3DERR_INVALIDCALL:
289 error =
"INVALIDCALL";
291 case D3DERR_DRIVERINVALIDCALL:
292 error =
"DRIVERINVALIDCALL";
294 case D3DERR_WASSTILLDRAWING:
295 error =
"WASSTILLDRAWING";
309 return D3DFMT_R5G6B5;
311 return D3DFMT_X8R8G8B8;
313 return D3DFMT_A8R8G8B8;
318 return D3DFMT_UNKNOWN;
323 D3DFMTToPixelFormat(D3DFORMAT format)
328 case D3DFMT_X8R8G8B8:
330 case D3DFMT_A8R8G8B8:
338 D3D_InitRenderState(D3D_RenderData *
data)
344 IDirect3DDevice9_SetVertexShader(device,
NULL);
345 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
346 IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
347 IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
348 IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING,
FALSE);
351 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP,
353 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1,
355 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2,
359 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAOP,
361 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG1,
363 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG2,
367 if (data->enableSeparateAlphaBlend) {
368 IDirect3DDevice9_SetRenderState(device, D3DRS_SEPARATEALPHABLENDENABLE,
TRUE);
372 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP,
374 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_ALPHAOP,
378 matrix.m[0][0] = 1.0f;
379 matrix.m[0][1] = 0.0f;
380 matrix.m[0][2] = 0.0f;
381 matrix.m[0][3] = 0.0f;
382 matrix.m[1][0] = 0.0f;
383 matrix.m[1][1] = 1.0f;
384 matrix.m[1][2] = 0.0f;
385 matrix.m[1][3] = 0.0f;
386 matrix.m[2][0] = 0.0f;
387 matrix.m[2][1] = 0.0f;
388 matrix.m[2][2] = 1.0f;
389 matrix.m[2][3] = 0.0f;
390 matrix.m[3][0] = 0.0f;
391 matrix.m[3][1] = 0.0f;
392 matrix.m[3][2] = 0.0f;
393 matrix.m[3][3] = 1.0f;
394 IDirect3DDevice9_SetTransform(device, D3DTS_WORLD, &matrix);
395 IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, &matrix);
398 SDL_memset(data->scaleMode, 0xFF,
sizeof(data->scaleMode));
407 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
412 if (data->defaultRenderTarget) {
413 IDirect3DSurface9_Release(data->defaultRenderTarget);
414 data->defaultRenderTarget =
NULL;
416 if (data->currentRenderTarget !=
NULL) {
417 IDirect3DSurface9_Release(data->currentRenderTarget);
418 data->currentRenderTarget =
NULL;
424 D3D_DestroyTexture(renderer,
texture);
426 D3D_RecreateTexture(renderer,
texture);
430 result = IDirect3DDevice9_Reset(data->device, &data->pparams);
432 if (result == D3DERR_DEVICELOST) {
436 return D3D_SetError(
"Reset()", result);
443 D3D_CreateTexture(renderer,
texture);
447 IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
448 D3D_InitRenderState(data);
449 D3D_SetRenderTargetInternal(renderer, renderer->
target);
450 D3D_UpdateViewport(renderer);
465 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
468 if (data->updateSize) {
474 data->pparams.BackBufferWidth =
w;
475 data->pparams.BackBufferHeight =
h;
479 data->pparams.Windowed =
FALSE;
480 data->pparams.BackBufferFormat = PixelFormatToD3DFMT(fullscreen_mode.
format);
481 data->pparams.FullScreen_RefreshRateInHz = fullscreen_mode.
refresh_rate;
483 data->pparams.Windowed =
TRUE;
484 data->pparams.BackBufferFormat = D3DFMT_UNKNOWN;
485 data->pparams.FullScreen_RefreshRateInHz = 0;
487 if (D3D_Reset(renderer) < 0) {
493 if (data->beginScene) {
494 result = IDirect3DDevice9_BeginScene(data->device);
495 if (result == D3DERR_DEVICELOST) {
496 if (D3D_Reset(renderer) < 0) {
499 result = IDirect3DDevice9_BeginScene(data->device);
502 return D3D_SetError(
"BeginScene()", result);
513 D3D_RenderData *
data;
516 D3DPRESENT_PARAMETERS pparams;
517 IDirect3DSwapChain9 *chain;
531 data = (D3D_RenderData *)
SDL_calloc(1,
sizeof(*data));
565 renderer->
info = D3D_RenderDriver.
info;
577 pparams.hDeviceWindow = windowinfo.
info.win.
window;
578 pparams.BackBufferWidth =
w;
579 pparams.BackBufferHeight =
h;
580 pparams.BackBufferCount = 1;
581 pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
583 if (window_flags &
SDL_WINDOW_FULLSCREEN && (window_flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP) {
584 pparams.Windowed =
FALSE;
585 pparams.BackBufferFormat = PixelFormatToD3DFMT(fullscreen_mode.
format);
586 pparams.FullScreen_RefreshRateInHz = fullscreen_mode.
refresh_rate;
588 pparams.Windowed =
TRUE;
589 pparams.BackBufferFormat = D3DFMT_UNKNOWN;
590 pparams.FullScreen_RefreshRateInHz = 0;
593 pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
595 pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
602 IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
604 device_flags = D3DCREATE_FPU_PRESERVE;
605 if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) {
606 device_flags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
608 device_flags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
612 device_flags |= D3DCREATE_MULTITHREADED;
615 result = IDirect3D9_CreateDevice(data->d3d, data->adapter,
617 pparams.hDeviceWindow,
619 &pparams, &data->device);
621 D3D_DestroyRenderer(renderer);
622 D3D_SetError(
"CreateDevice()", result);
627 result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);
629 D3D_DestroyRenderer(renderer);
630 D3D_SetError(
"GetSwapChain()", result);
633 result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);
635 IDirect3DSwapChain9_Release(chain);
636 D3D_DestroyRenderer(renderer);
637 D3D_SetError(
"GetPresentParameters()", result);
640 IDirect3DSwapChain9_Release(chain);
641 if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
644 data->pparams = pparams;
646 IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
649 if (caps.NumSimultaneousRTs >= 2) {
653 if (caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) {
654 data->enableSeparateAlphaBlend =
SDL_TRUE;
658 IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
659 data->currentRenderTarget =
NULL;
662 D3D_InitRenderState(data);
664 if (caps.MaxSimultaneousTextures >= 3)
666 #ifdef ASSEMBLE_SHADER 727 const char *shader_text =
729 "def c0, -0.0627451017, -0.501960814, -0.501960814, 1\n" 730 "def c1, 1.16400003, 0, 1.59599996, 0\n" 731 "def c2, 1.16400003, -0.391000003, -0.813000023, 0\n" 732 "def c3, 1.16400003, 2.01799989, 0, 0\n" 743 "add r0.xyz, r0, c0\n" 746 "dp2add r1.z, r0, c3, c3.z\n" 752 LPD3DXBUFFER pErrorMsgs;
753 LPDWORD shader_data =
NULL;
754 DWORD shader_size = 0;
755 result = D3DXAssembleShader(shader_text,
SDL_strlen(shader_text),
NULL,
NULL, 0, &pCode, &pErrorMsgs);
757 shader_data = (DWORD*)pCode->lpVtbl->GetBufferPointer(pCode);
758 shader_size = pCode->lpVtbl->GetBufferSize(pCode);
759 PrintShaderData(shader_data, shader_size);
761 const char *error = (
const char *)pErrorMsgs->lpVtbl->GetBufferPointer(pErrorMsgs);
764 if (shader_data !=
NULL)
766 const DWORD shader_data[] = {
767 0xffff0200, 0x05000051, 0xa00f0000, 0xbd808081, 0xbf008081, 0xbf008081,
768 0x3f800000, 0x05000051, 0xa00f0001, 0x3f94fdf4, 0x00000000, 0x3fcc49ba,
769 0x00000000, 0x05000051, 0xa00f0002, 0x3f94fdf4, 0xbec83127, 0xbf5020c5,
770 0x00000000, 0x05000051, 0xa00f0003, 0x3f94fdf4, 0x400126e9, 0x00000000,
771 0x00000000, 0x0200001f, 0x80000000, 0xb0030000, 0x0200001f, 0x80000000,
772 0x900f0000, 0x0200001f, 0x90000000, 0xa00f0800, 0x0200001f, 0x90000000,
773 0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000,
774 0xb0e40000, 0xa0e40800, 0x03000042, 0x800f0001, 0xb0e40000, 0xa0e40801,
775 0x03000042, 0x800f0002, 0xb0e40000, 0xa0e40802, 0x02000001, 0x80020000,
776 0x80000001, 0x02000001, 0x80040000, 0x80000002, 0x03000002, 0x80070000,
777 0x80e40000, 0xa0e40000, 0x03000008, 0x80010001, 0x80e40000, 0xa0e40001,
778 0x03000008, 0x80020001, 0x80e40000, 0xa0e40002, 0x0400005a, 0x80040001,
779 0x80e40000, 0xa0e40003, 0xa0aa0003, 0x02000001, 0x80080001, 0xa0ff0000,
780 0x03000005, 0x800f0000, 0x80e40001, 0x90e40000, 0x02000001, 0x800f0800,
781 0x80e40000, 0x0000ffff
785 result = IDirect3DDevice9_CreatePixelShader(data->device, shader_data, &data->ps_yuv);
790 D3D_SetError(
"CreatePixelShader()", result);
801 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
812 return D3DBLEND_ZERO;
816 return D3DBLEND_SRCCOLOR;
818 return D3DBLEND_INVSRCCOLOR;
820 return D3DBLEND_SRCALPHA;
822 return D3DBLEND_INVSRCALPHA;
824 return D3DBLEND_DESTCOLOR;
826 return D3DBLEND_INVDESTCOLOR;
828 return D3DBLEND_DESTALPHA;
830 return D3DBLEND_INVDESTALPHA;
839 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
847 if (!GetBlendFunc(srcColorFactor) || !GetBlendFunc(srcAlphaFactor) ||
848 !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor)) {
851 if ((srcColorFactor != srcAlphaFactor || dstColorFactor != dstAlphaFactor) && !data->enableSeparateAlphaBlend) {
860 static D3DTEXTUREFILTERTYPE
865 if (!hint || *hint ==
'0' ||
SDL_strcasecmp(hint,
"nearest") == 0) {
866 return D3DTEXF_POINT;
868 return D3DTEXF_LINEAR;
880 texture->usage =
usage;
883 result = IDirect3DDevice9_CreateTexture(device, w, h, 1, usage,
884 PixelFormatToD3DFMT(format),
885 D3DPOOL_DEFAULT, &texture->texture,
NULL);
887 return D3D_SetError(
"CreateTexture(D3DPOOL_DEFAULT)", result);
898 if (texture->staging ==
NULL) {
899 result = IDirect3DDevice9_CreateTexture(device, texture->w, texture->h, 1, 0,
900 PixelFormatToD3DFMT(texture->format),
901 D3DPOOL_SYSTEMMEM, &texture->staging,
NULL);
903 return D3D_SetError(
"CreateTexture(D3DPOOL_SYSTEMMEM)", result);
914 if (texture->dirty && texture->staging) {
915 if (!texture->texture) {
916 result = IDirect3DDevice9_CreateTexture(device, texture->w, texture->h, 1, texture->usage,
917 PixelFormatToD3DFMT(texture->format), D3DPOOL_DEFAULT, &texture->texture,
NULL);
919 return D3D_SetError(
"CreateTexture(D3DPOOL_DEFAULT)", result);
923 result = IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)texture->staging, (IDirect3DBaseTexture9 *)texture->texture);
925 return D3D_SetError(
"UpdateTexture()", result);
929 result = IDirect3DDevice9_SetTexture(device, sampler, (IDirect3DBaseTexture9 *)texture->texture);
931 return D3D_SetError(
"SetTexture()", result);
939 if (texture->texture) {
940 IDirect3DTexture9_Release(texture->texture);
941 texture->texture =
NULL;
943 if (texture->staging) {
944 IDirect3DTexture9_AddDirtyRect(texture->staging,
NULL);
954 D3DLOCKED_RECT locked;
960 if (D3D_CreateStagingTexture(device, texture) < 0) {
965 d3drect.right = x +
w;
967 d3drect.bottom = y +
h;
969 result = IDirect3DTexture9_LockRect(texture->staging, 0, &locked, &d3drect, 0);
971 return D3D_SetError(
"LockRect()", result);
974 src = (
const Uint8 *)pixels;
977 if (length == pitch && length == locked.Pitch) {
980 if (length > pitch) {
983 if (length > locked.Pitch) {
984 length = locked.Pitch;
986 for (row = 0; row <
h; ++
row) {
992 result = IDirect3DTexture9_UnlockRect(texture->staging, 0);
994 return D3D_SetError(
"UnlockRect()", result);
1002 D3D_DestroyTextureRep(D3D_TextureRep *texture)
1004 if (texture->texture) {
1005 IDirect3DTexture9_Release(texture->texture);
1006 texture->texture =
NULL;
1008 if (texture->staging) {
1009 IDirect3DTexture9_Release(texture->staging);
1010 texture->staging =
NULL;
1017 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1018 D3D_TextureData *texturedata;
1021 texturedata = (D3D_TextureData *)
SDL_calloc(1,
sizeof(*texturedata));
1030 usage = D3DUSAGE_RENDERTARGET;
1035 if (D3D_CreateTextureRep(data->device, &texturedata->texture, usage, texture->
format, texture->
w, texture->
h) < 0) {
1043 if (D3D_CreateTextureRep(data->device, &texturedata->utexture, usage, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
1047 if (D3D_CreateTextureRep(data->device, &texturedata->vtexture, usage, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
1057 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1058 D3D_TextureData *texturedata = (D3D_TextureData *)texture->
driverdata;
1064 if (D3D_RecreateTextureRep(data->device, &texturedata->texture, texture->
format, texture->
w, texture->
h) < 0) {
1068 if (texturedata->yuv) {
1069 if (D3D_RecreateTextureRep(data->device, &texturedata->utexture, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
1073 if (D3D_RecreateTextureRep(data->device, &texturedata->vtexture, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
1084 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1085 D3D_TextureData *texturedata = (D3D_TextureData *) texture->
driverdata;
1092 if (D3D_UpdateTextureRep(data->device, &texturedata->texture, texture->
format, rect->
x, rect->
y, rect->
w, rect->
h, pixels, pitch) < 0) {
1096 if (texturedata->yuv) {
1098 pixels = (
const void*)((
const Uint8*)pixels + rect->
h * pitch);
1100 if (D3D_UpdateTextureRep(data->device, texture->
format ==
SDL_PIXELFORMAT_YV12 ? &texturedata->vtexture : &texturedata->utexture, texture->
format, rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, pixels, pitch / 2) < 0) {
1105 pixels = (
const void*)((
const Uint8*)pixels + (rect->
h * pitch)/4);
1106 if (D3D_UpdateTextureRep(data->device, texture->
format ==
SDL_PIXELFORMAT_YV12 ? &texturedata->utexture : &texturedata->vtexture, texture->
format, rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, pixels, pitch / 2) < 0) {
1116 const Uint8 *Yplane,
int Ypitch,
1117 const Uint8 *Uplane,
int Upitch,
1118 const Uint8 *Vplane,
int Vpitch)
1120 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1121 D3D_TextureData *texturedata = (D3D_TextureData *) texture->
driverdata;
1128 if (D3D_UpdateTextureRep(data->device, &texturedata->texture, texture->
format, rect->
x, rect->
y, rect->
w, rect->
h, Yplane, Ypitch) < 0) {
1131 if (D3D_UpdateTextureRep(data->device, &texturedata->utexture, texture->
format, rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, Uplane, Upitch) < 0) {
1134 if (D3D_UpdateTextureRep(data->device, &texturedata->vtexture, texture->
format, rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, Vplane, Vpitch) < 0) {
1142 const SDL_Rect * rect,
void **pixels,
int *pitch)
1144 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1145 D3D_TextureData *texturedata = (D3D_TextureData *)texture->
driverdata;
1153 texturedata->locked_rect = *
rect;
1155 if (texturedata->yuv) {
1157 if (!texturedata->pixels) {
1158 texturedata->pitch = texture->
w;
1159 texturedata->pixels = (
Uint8 *)
SDL_malloc((texture->
h * texturedata->pitch * 3) / 2);
1160 if (!texturedata->pixels) {
1165 (
void *) ((
Uint8 *) texturedata->pixels + rect->
y * texturedata->pitch +
1167 *pitch = texturedata->pitch;
1170 D3DLOCKED_RECT locked;
1173 if (D3D_CreateStagingTexture(device, &texturedata->texture) < 0) {
1177 d3drect.left = rect->
x;
1178 d3drect.right = rect->
x + rect->
w;
1179 d3drect.top = rect->
y;
1180 d3drect.bottom = rect->
y + rect->
h;
1182 result = IDirect3DTexture9_LockRect(texturedata->texture.staging, 0, &locked, &d3drect, 0);
1184 return D3D_SetError(
"LockRect()", result);
1186 *pixels = locked.pBits;
1187 *pitch = locked.Pitch;
1196 D3D_TextureData *texturedata = (D3D_TextureData *)texture->
driverdata;
1202 if (texturedata->yuv) {
1203 const SDL_Rect *rect = &texturedata->locked_rect;
1205 (
void *) ((
Uint8 *) texturedata->pixels + rect->
y * texturedata->pitch +
1207 D3D_UpdateTexture(renderer, texture, rect, pixels, texturedata->pitch);
1209 IDirect3DTexture9_UnlockRect(texturedata->texture.staging, 0);
1210 texturedata->texture.dirty =
SDL_TRUE;
1217 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1218 D3D_TextureData *texturedata;
1219 D3D_TextureRep *texturerep;
1224 if (data->currentRenderTarget !=
NULL) {
1225 IDirect3DSurface9_Release(data->currentRenderTarget);
1226 data->currentRenderTarget =
NULL;
1229 if (texture ==
NULL) {
1230 IDirect3DDevice9_SetRenderTarget(data->device, 0, data->defaultRenderTarget);
1234 texturedata = (D3D_TextureData *)texture->
driverdata;
1241 texturerep = &texturedata->texture;
1242 if (texturerep->dirty && texturerep->staging) {
1243 if (!texturerep->texture) {
1244 result = IDirect3DDevice9_CreateTexture(device, texturerep->w, texturerep->h, 1, texturerep->usage,
1245 PixelFormatToD3DFMT(texturerep->format), D3DPOOL_DEFAULT, &texturerep->texture,
NULL);
1247 return D3D_SetError(
"CreateTexture(D3DPOOL_DEFAULT)", result);
1251 result = IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)texturerep->staging, (IDirect3DBaseTexture9 *)texturerep->texture);
1253 return D3D_SetError(
"UpdateTexture()", result);
1258 result = IDirect3DTexture9_GetSurfaceLevel(texturedata->texture.texture, 0, &data->currentRenderTarget);
1260 return D3D_SetError(
"GetSurfaceLevel()", result);
1262 result = IDirect3DDevice9_SetRenderTarget(data->device, 0, data->currentRenderTarget);
1264 return D3D_SetError(
"SetRenderTarget()", result);
1273 D3D_ActivateRenderer(renderer);
1275 return D3D_SetRenderTargetInternal(renderer, texture);
1281 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1292 IDirect3DDevice9_SetViewport(data->device, &
viewport);
1296 matrix.m[0][0] = 2.0f / renderer->
viewport.
w;
1297 matrix.m[0][1] = 0.0f;
1298 matrix.m[0][2] = 0.0f;
1299 matrix.m[0][3] = 0.0f;
1300 matrix.m[1][0] = 0.0f;
1301 matrix.m[1][1] = -2.0f / renderer->
viewport.
h;
1302 matrix.m[1][2] = 0.0f;
1303 matrix.m[1][3] = 0.0f;
1304 matrix.m[2][0] = 0.0f;
1305 matrix.m[2][1] = 0.0f;
1306 matrix.m[2][2] = 1.0f;
1307 matrix.m[2][3] = 0.0f;
1308 matrix.m[3][0] = -1.0f;
1309 matrix.m[3][1] = 1.0f;
1310 matrix.m[3][2] = 0.0f;
1311 matrix.m[3][3] = 1.0f;
1312 IDirect3DDevice9_SetTransform(data->device, D3DTS_PROJECTION, &matrix);
1321 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1328 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
TRUE);
1331 r.right = renderer->
viewport.
x + rect->
x + rect->
w;
1332 r.bottom = renderer->
viewport.
y + rect->
y + rect->
h;
1334 result = IDirect3DDevice9_SetScissorRect(data->device, &r);
1335 if (result != D3D_OK) {
1336 D3D_SetError(
"SetScissor()", result);
1340 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
FALSE);
1348 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1351 int BackBufferWidth, BackBufferHeight;
1353 if (D3D_ActivateRenderer(renderer) < 0) {
1357 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1360 BackBufferWidth = renderer->
target->
w;
1361 BackBufferHeight = renderer->
target->
h;
1363 BackBufferWidth = data->pparams.BackBufferWidth;
1364 BackBufferHeight = data->pparams.BackBufferHeight;
1368 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
FALSE);
1373 renderer->
viewport.
w == BackBufferWidth &&
1374 renderer->
viewport.
h == BackBufferHeight) {
1375 result = IDirect3DDevice9_Clear(data->device, 0,
NULL, D3DCLEAR_TARGET,
color, 0.0f, 0);
1382 viewport.Width = BackBufferWidth;
1383 viewport.Height = BackBufferHeight;
1384 viewport.MinZ = 0.0f;
1385 viewport.MaxZ = 1.0f;
1386 IDirect3DDevice9_SetViewport(data->device, &viewport);
1388 result = IDirect3DDevice9_Clear(data->device, 0,
NULL, D3DCLEAR_TARGET,
color, 0.0f, 0);
1395 viewport.MinZ = 0.0f;
1396 viewport.MaxZ = 1.0f;
1397 IDirect3DDevice9_SetViewport(data->device, &viewport);
1401 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
TRUE);
1405 return D3D_SetError(
"Clear()", result);
1411 D3D_SetBlendMode(D3D_RenderData * data,
SDL_BlendMode blendMode)
1414 IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
FALSE);
1416 IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
TRUE);
1417 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
1419 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
1421 if (data->enableSeparateAlphaBlend) {
1422 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLENDALPHA,
1424 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLENDALPHA,
1434 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1440 if (D3D_ActivateRenderer(renderer) < 0) {
1444 D3D_SetBlendMode(data, renderer->
blendMode);
1447 IDirect3DDevice9_SetTexture(data->device, 0,
1448 (IDirect3DBaseTexture9 *) 0);
1450 return D3D_SetError(
"SetTexture()", result);
1453 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1456 for (i = 0; i <
count; ++
i) {
1457 vertices[
i].x = points[
i].
x;
1458 vertices[
i].y = points[
i].
y;
1459 vertices[
i].z = 0.0f;
1460 vertices[
i].color =
color;
1461 vertices[
i].u = 0.0f;
1462 vertices[
i].v = 0.0f;
1465 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, count,
1466 vertices,
sizeof(*vertices));
1469 return D3D_SetError(
"DrawPrimitiveUP()", result);
1478 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1484 if (D3D_ActivateRenderer(renderer) < 0) {
1488 D3D_SetBlendMode(data, renderer->
blendMode);
1491 IDirect3DDevice9_SetTexture(data->device, 0,
1492 (IDirect3DBaseTexture9 *) 0);
1494 return D3D_SetError(
"SetTexture()", result);
1497 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1500 for (i = 0; i <
count; ++
i) {
1501 vertices[
i].x = points[
i].
x;
1502 vertices[
i].y = points[
i].
y;
1503 vertices[
i].z = 0.0f;
1504 vertices[
i].color =
color;
1505 vertices[
i].u = 0.0f;
1506 vertices[
i].v = 0.0f;
1509 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_LINESTRIP, count-1,
1510 vertices,
sizeof(*vertices));
1515 points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
1516 vertices[0].x = points[count-1].
x;
1517 vertices[0].y = points[count-1].
y;
1518 result = IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, 1, vertices,
sizeof(*vertices));
1523 return D3D_SetError(
"DrawPrimitiveUP()", result);
1532 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1535 float minx, miny, maxx, maxy;
1539 if (D3D_ActivateRenderer(renderer) < 0) {
1543 D3D_SetBlendMode(data, renderer->
blendMode);
1546 IDirect3DDevice9_SetTexture(data->device, 0,
1547 (IDirect3DBaseTexture9 *) 0);
1549 return D3D_SetError(
"SetTexture()", result);
1552 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1554 for (i = 0; i <
count; ++
i) {
1559 maxx = rect->
x + rect->
w;
1560 maxy = rect->
y + rect->
h;
1562 vertices[0].x = minx;
1563 vertices[0].y = miny;
1564 vertices[0].z = 0.0f;
1565 vertices[0].color =
color;
1566 vertices[0].u = 0.0f;
1567 vertices[0].v = 0.0f;
1569 vertices[1].x = maxx;
1570 vertices[1].y = miny;
1571 vertices[1].z = 0.0f;
1572 vertices[1].color =
color;
1573 vertices[1].u = 0.0f;
1574 vertices[1].v = 0.0f;
1576 vertices[2].x = maxx;
1577 vertices[2].y = maxy;
1578 vertices[2].z = 0.0f;
1579 vertices[2].color =
color;
1580 vertices[2].u = 0.0f;
1581 vertices[2].v = 0.0f;
1583 vertices[3].x = minx;
1584 vertices[3].y = maxy;
1585 vertices[3].z = 0.0f;
1586 vertices[3].color =
color;
1587 vertices[3].u = 0.0f;
1588 vertices[3].v = 0.0f;
1591 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN,
1592 2, vertices,
sizeof(*vertices));
1594 return D3D_SetError(
"DrawPrimitiveUP()", result);
1601 D3D_UpdateTextureScaleMode(D3D_RenderData *data, D3D_TextureData *texturedata,
unsigned index)
1603 if (texturedata->scaleMode != data->scaleMode[index]) {
1604 IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MINFILTER,
1605 texturedata->scaleMode);
1606 IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MAGFILTER,
1607 texturedata->scaleMode);
1608 data->scaleMode[
index] = texturedata->scaleMode;
1616 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1617 D3D_TextureData *texturedata;
1619 float minx, miny, maxx, maxy;
1620 float minu, maxu, minv, maxv;
1625 if (D3D_ActivateRenderer(renderer) < 0) {
1629 texturedata = (D3D_TextureData *)texture->
driverdata;
1635 minx = dstrect->
x - 0.5f;
1636 miny = dstrect->
y - 0.5f;
1637 maxx = dstrect->
x + dstrect->
w - 0.5f;
1638 maxy = dstrect->
y + dstrect->
h - 0.5f;
1640 minu = (float) srcrect->
x / texture->
w;
1641 maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
1642 minv = (
float) srcrect->
y / texture->
h;
1643 maxv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
1645 color = D3DCOLOR_ARGB(texture->
a, texture->
r, texture->
g, texture->
b);
1647 vertices[0].x = minx;
1648 vertices[0].y = miny;
1649 vertices[0].z = 0.0f;
1650 vertices[0].color =
color;
1651 vertices[0].u = minu;
1652 vertices[0].v = minv;
1654 vertices[1].x = maxx;
1655 vertices[1].y = miny;
1656 vertices[1].z = 0.0f;
1657 vertices[1].color =
color;
1658 vertices[1].u = maxu;
1659 vertices[1].v = minv;
1661 vertices[2].x = maxx;
1662 vertices[2].y = maxy;
1663 vertices[2].z = 0.0f;
1664 vertices[2].color =
color;
1665 vertices[2].u = maxu;
1666 vertices[2].v = maxv;
1668 vertices[3].x = minx;
1669 vertices[3].y = maxy;
1670 vertices[3].z = 0.0f;
1671 vertices[3].color =
color;
1672 vertices[3].u = minu;
1673 vertices[3].v = maxv;
1675 D3D_SetBlendMode(data, texture->
blendMode);
1677 D3D_UpdateTextureScaleMode(data, texturedata, 0);
1679 if (D3D_BindTextureRep(data->device, &texturedata->texture, 0) < 0) {
1683 if (texturedata->yuv) {
1686 D3D_UpdateTextureScaleMode(data, texturedata, 1);
1687 D3D_UpdateTextureScaleMode(data, texturedata, 2);
1689 if (D3D_BindTextureRep(data->device, &texturedata->utexture, 1) < 0) {
1692 if (D3D_BindTextureRep(data->device, &texturedata->vtexture, 2) < 0) {
1698 result = IDirect3DDevice9_SetPixelShader(data->device,
shader);
1700 return D3D_SetError(
"SetShader()", result);
1704 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
1705 vertices,
sizeof(*vertices));
1707 return D3D_SetError(
"DrawPrimitiveUP()", result);
1710 result = IDirect3DDevice9_SetPixelShader(data->device,
NULL);
1712 return D3D_SetError(
"SetShader()", result);
1724 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1725 D3D_TextureData *texturedata;
1727 float minx, miny, maxx, maxy;
1728 float minu, maxu, minv, maxv;
1729 float centerx, centery;
1732 Float4X4 modelMatrix;
1735 if (D3D_ActivateRenderer(renderer) < 0) {
1739 texturedata = (D3D_TextureData *)texture->
driverdata;
1745 centerx = center->
x;
1746 centery = center->
y;
1749 maxx = dstrect->
w - centerx;
1751 maxy = dstrect->
h - centery;
1753 minu = (float) srcrect->
x / texture->
w;
1754 maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
1755 minv = (
float) srcrect->
y / texture->
h;
1756 maxv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
1769 color = D3DCOLOR_ARGB(texture->
a, texture->
r, texture->
g, texture->
b);
1771 vertices[0].x = minx;
1772 vertices[0].y = miny;
1773 vertices[0].z = 0.0f;
1774 vertices[0].color =
color;
1775 vertices[0].u = minu;
1776 vertices[0].v = minv;
1778 vertices[1].x = maxx;
1779 vertices[1].y = miny;
1780 vertices[1].z = 0.0f;
1781 vertices[1].color =
color;
1782 vertices[1].u = maxu;
1783 vertices[1].v = minv;
1785 vertices[2].x = maxx;
1786 vertices[2].y = maxy;
1787 vertices[2].z = 0.0f;
1788 vertices[2].color =
color;
1789 vertices[2].u = maxu;
1790 vertices[2].v = maxv;
1792 vertices[3].x = minx;
1793 vertices[3].y = maxy;
1794 vertices[3].z = 0.0f;
1795 vertices[3].color =
color;
1796 vertices[3].u = minu;
1797 vertices[3].v = maxv;
1799 D3D_SetBlendMode(data, texture->
blendMode);
1802 modelMatrix = MatrixMultiply(
1803 MatrixRotationZ((
float)(M_PI * (
float) angle / 180.0
f)),
1804 MatrixTranslation(dstrect->
x + center->
x - 0.5f, dstrect->
y + center->
y - 0.5f, 0));
1805 IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)&modelMatrix);
1807 D3D_UpdateTextureScaleMode(data, texturedata, 0);
1809 if (D3D_BindTextureRep(data->device, &texturedata->texture, 0) < 0) {
1813 if (texturedata->yuv) {
1816 D3D_UpdateTextureScaleMode(data, texturedata, 1);
1817 D3D_UpdateTextureScaleMode(data, texturedata, 2);
1819 if (D3D_BindTextureRep(data->device, &texturedata->utexture, 1) < 0) {
1822 if (D3D_BindTextureRep(data->device, &texturedata->vtexture, 2) < 0) {
1828 result = IDirect3DDevice9_SetPixelShader(data->device,
shader);
1830 return D3D_SetError(
"SetShader()", result);
1834 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
1835 vertices,
sizeof(*vertices));
1837 return D3D_SetError(
"DrawPrimitiveUP()", result);
1840 result = IDirect3DDevice9_SetPixelShader(data->device,
NULL);
1842 return D3D_SetError(
"SetShader()", result);
1846 modelMatrix = MatrixIdentity();
1847 IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)&modelMatrix);
1853 Uint32 format,
void * pixels,
int pitch)
1855 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1856 D3DSURFACE_DESC desc;
1857 LPDIRECT3DSURFACE9 backBuffer;
1860 D3DLOCKED_RECT locked;
1863 if (data->currentRenderTarget) {
1864 backBuffer = data->currentRenderTarget;
1866 backBuffer = data->defaultRenderTarget;
1869 result = IDirect3DSurface9_GetDesc(backBuffer, &desc);
1871 IDirect3DSurface9_Release(backBuffer);
1872 return D3D_SetError(
"GetDesc()", result);
1875 result = IDirect3DDevice9_CreateOffscreenPlainSurface(data->device, desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &
surface,
NULL);
1877 IDirect3DSurface9_Release(backBuffer);
1878 return D3D_SetError(
"CreateOffscreenPlainSurface()", result);
1881 result = IDirect3DDevice9_GetRenderTargetData(data->device, backBuffer,
surface);
1883 IDirect3DSurface9_Release(
surface);
1884 IDirect3DSurface9_Release(backBuffer);
1885 return D3D_SetError(
"GetRenderTargetData()", result);
1888 d3drect.left = rect->
x;
1889 d3drect.right = rect->
x + rect->
w;
1890 d3drect.top = rect->
y;
1891 d3drect.bottom = rect->
y + rect->
h;
1893 result = IDirect3DSurface9_LockRect(
surface, &locked, &d3drect, D3DLOCK_READONLY);
1895 IDirect3DSurface9_Release(
surface);
1896 IDirect3DSurface9_Release(backBuffer);
1897 return D3D_SetError(
"LockRect()", result);
1901 D3DFMTToPixelFormat(desc.Format), locked.pBits, locked.Pitch,
1902 format, pixels, pitch);
1904 IDirect3DSurface9_UnlockRect(
surface);
1906 IDirect3DSurface9_Release(
surface);
1914 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1917 if (!data->beginScene) {
1918 IDirect3DDevice9_EndScene(data->device);
1922 result = IDirect3DDevice9_TestCooperativeLevel(data->device);
1923 if (result == D3DERR_DEVICELOST) {
1927 if (result == D3DERR_DEVICENOTRESET) {
1928 D3D_Reset(renderer);
1932 D3D_SetError(
"Present()", result);
1939 D3D_TextureData *data = (D3D_TextureData *) texture->
driverdata;
1944 D3D_DestroyTextureRep(&data->texture);
1945 D3D_DestroyTextureRep(&data->utexture);
1946 D3D_DestroyTextureRep(&data->vtexture);
1955 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1959 if (data->defaultRenderTarget) {
1960 IDirect3DSurface9_Release(data->defaultRenderTarget);
1961 data->defaultRenderTarget =
NULL;
1963 if (data->currentRenderTarget !=
NULL) {
1964 IDirect3DSurface9_Release(data->currentRenderTarget);
1965 data->currentRenderTarget =
NULL;
1968 IDirect3DPixelShader9_Release(data->ps_yuv);
1971 IDirect3DDevice9_Release(data->device);
1974 IDirect3D9_Release(data->d3d);
1990 #if SDL_VIDEO_RENDER_D3D && !SDL_RENDER_DISABLED 1991 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1999 device = data->device;
2001 IDirect3DDevice9_AddRef(device);
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)
struct IDirect3D9 IDirect3D9
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)
#define SDL_GetWindowDisplayIndex
GLuint GLfloat GLfloat GLfloat x1
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.
GLfloat GLfloat GLfloat GLfloat h
Uint32 texture_formats[16]
The structure that defines a display mode.
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
#define SDL_GetWindowFlags
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)
uint32_t Uint32
An unsigned 32-bit integer type.
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
int(* RenderClear)(SDL_Renderer *renderer)
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.
int SDL_Direct3D9GetAdapterIndex(int displayIndex)
Returns the D3D9 adapter index that matches the specified display index.
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)
static SDL_AudioDeviceID device
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
GLsizeiptr const void GLenum usage
GLenum GLenum GLuint texture
void * SDL_calloc(size_t nmemb, size_t size)
#define SDL_GetWindowDisplayMode
SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
static int GetScaleQuality(void)
static SDL_Renderer * renderer
uint8_t Uint8
An unsigned 8-bit integer type.
#define SDL_stack_alloc(type, count)
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)
SDL_RenderDriver D3D_RenderDriver
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
SDL_bool D3D_LoadDLL(void **pD3DDLL, IDirect3D9 **pDirect3D9Interface)
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
#define SDL_HINT_RENDER_DIRECT3D_THREADSAFE
A variable controlling whether the Direct3D device is initialized for thread-safe operations...
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)
Uint32 num_texture_formats
union SDL_SysWMinfo::@18 info
#define SDL_ConvertPixels
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
void(* RenderPresent)(SDL_Renderer *renderer)
EGLSurface EGLint * rects
#define SDL_stack_free(data)
GLuint GLsizei GLsizei * length
int(* UpdateClipRect)(SDL_Renderer *renderer)
IDirect3DDevice9 * SDL_RenderGetD3D9Device(SDL_Renderer *renderer)
Returns the D3D device associated with a renderer, or NULL if it's not a D3D renderer.
SDL_bool clipping_enabled
A rectangle, with the origin at the upper left.
struct IDirect3DDevice9 IDirect3DDevice9