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");
135 const Uint8 *Yplane,
int Ypitch,
136 const Uint8 *Uplane,
int Upitch,
137 const Uint8 *Vplane,
int Vpitch);
182 D3DPRESENT_PARAMETERS pparams;
186 D3DTEXTUREFILTERTYPE scaleMode[8];
187 IDirect3DSurface9 *defaultRenderTarget;
188 IDirect3DSurface9 *currentRenderTarget;
190 LPDIRECT3DPIXELSHADER9 ps_yuv;
200 IDirect3DTexture9 *staging;
206 D3DTEXTUREFILTERTYPE scaleMode;
210 D3D_TextureRep utexture;
211 D3D_TextureRep vtexture;
225 D3D_SetError(
const char *prefix, HRESULT
result)
230 case D3DERR_WRONGTEXTUREFORMAT:
231 error =
"WRONGTEXTUREFORMAT";
233 case D3DERR_UNSUPPORTEDCOLOROPERATION:
234 error =
"UNSUPPORTEDCOLOROPERATION";
236 case D3DERR_UNSUPPORTEDCOLORARG:
237 error =
"UNSUPPORTEDCOLORARG";
239 case D3DERR_UNSUPPORTEDALPHAOPERATION:
240 error =
"UNSUPPORTEDALPHAOPERATION";
242 case D3DERR_UNSUPPORTEDALPHAARG:
243 error =
"UNSUPPORTEDALPHAARG";
245 case D3DERR_TOOMANYOPERATIONS:
246 error =
"TOOMANYOPERATIONS";
248 case D3DERR_CONFLICTINGTEXTUREFILTER:
249 error =
"CONFLICTINGTEXTUREFILTER";
251 case D3DERR_UNSUPPORTEDFACTORVALUE:
252 error =
"UNSUPPORTEDFACTORVALUE";
254 case D3DERR_CONFLICTINGRENDERSTATE:
255 error =
"CONFLICTINGRENDERSTATE";
257 case D3DERR_UNSUPPORTEDTEXTUREFILTER:
258 error =
"UNSUPPORTEDTEXTUREFILTER";
260 case D3DERR_CONFLICTINGTEXTUREPALETTE:
261 error =
"CONFLICTINGTEXTUREPALETTE";
263 case D3DERR_DRIVERINTERNALERROR:
264 error =
"DRIVERINTERNALERROR";
266 case D3DERR_NOTFOUND:
269 case D3DERR_MOREDATA:
272 case D3DERR_DEVICELOST:
273 error =
"DEVICELOST";
275 case D3DERR_DEVICENOTRESET:
276 error =
"DEVICENOTRESET";
278 case D3DERR_NOTAVAILABLE:
279 error =
"NOTAVAILABLE";
281 case D3DERR_OUTOFVIDEOMEMORY:
282 error =
"OUTOFVIDEOMEMORY";
284 case D3DERR_INVALIDDEVICE:
285 error =
"INVALIDDEVICE";
287 case D3DERR_INVALIDCALL:
288 error =
"INVALIDCALL";
290 case D3DERR_DRIVERINVALIDCALL:
291 error =
"DRIVERINVALIDCALL";
293 case D3DERR_WASSTILLDRAWING:
294 error =
"WASSTILLDRAWING";
308 return D3DFMT_R5G6B5;
310 return D3DFMT_X8R8G8B8;
312 return D3DFMT_A8R8G8B8;
317 return D3DFMT_UNKNOWN;
322 D3DFMTToPixelFormat(D3DFORMAT format)
327 case D3DFMT_X8R8G8B8:
329 case D3DFMT_A8R8G8B8:
337 D3D_InitRenderState(D3D_RenderData *
data)
343 IDirect3DDevice9_SetVertexShader(device,
NULL);
344 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
345 IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
346 IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
347 IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING,
FALSE);
350 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP,
352 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1,
354 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2,
358 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAOP,
360 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG1,
362 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG2,
366 if (data->enableSeparateAlphaBlend) {
367 IDirect3DDevice9_SetRenderState(device, D3DRS_SEPARATEALPHABLENDENABLE,
TRUE);
371 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP,
373 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_ALPHAOP,
377 matrix.m[0][0] = 1.0f;
378 matrix.m[0][1] = 0.0f;
379 matrix.m[0][2] = 0.0f;
380 matrix.m[0][3] = 0.0f;
381 matrix.m[1][0] = 0.0f;
382 matrix.m[1][1] = 1.0f;
383 matrix.m[1][2] = 0.0f;
384 matrix.m[1][3] = 0.0f;
385 matrix.m[2][0] = 0.0f;
386 matrix.m[2][1] = 0.0f;
387 matrix.m[2][2] = 1.0f;
388 matrix.m[2][3] = 0.0f;
389 matrix.m[3][0] = 0.0f;
390 matrix.m[3][1] = 0.0f;
391 matrix.m[3][2] = 0.0f;
392 matrix.m[3][3] = 1.0f;
393 IDirect3DDevice9_SetTransform(device, D3DTS_WORLD, &matrix);
394 IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, &matrix);
397 SDL_memset(data->scaleMode, 0xFF,
sizeof(data->scaleMode));
406 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
411 if (data->defaultRenderTarget) {
412 IDirect3DSurface9_Release(data->defaultRenderTarget);
413 data->defaultRenderTarget =
NULL;
415 if (data->currentRenderTarget !=
NULL) {
416 IDirect3DSurface9_Release(data->currentRenderTarget);
417 data->currentRenderTarget =
NULL;
423 D3D_DestroyTexture(renderer,
texture);
425 D3D_RecreateTexture(renderer,
texture);
429 result = IDirect3DDevice9_Reset(data->device, &data->pparams);
431 if (result == D3DERR_DEVICELOST) {
435 return D3D_SetError(
"Reset()", result);
442 D3D_CreateTexture(renderer,
texture);
446 IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
447 D3D_InitRenderState(data);
448 D3D_SetRenderTargetInternal(renderer, renderer->
target);
449 D3D_UpdateViewport(renderer);
464 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
467 if (data->updateSize) {
473 data->pparams.BackBufferWidth =
w;
474 data->pparams.BackBufferHeight =
h;
478 data->pparams.Windowed =
FALSE;
479 data->pparams.BackBufferFormat = PixelFormatToD3DFMT(fullscreen_mode.
format);
480 data->pparams.FullScreen_RefreshRateInHz = fullscreen_mode.
refresh_rate;
482 data->pparams.Windowed =
TRUE;
483 data->pparams.BackBufferFormat = D3DFMT_UNKNOWN;
484 data->pparams.FullScreen_RefreshRateInHz = 0;
486 if (D3D_Reset(renderer) < 0) {
492 if (data->beginScene) {
493 result = IDirect3DDevice9_BeginScene(data->device);
494 if (result == D3DERR_DEVICELOST) {
495 if (D3D_Reset(renderer) < 0) {
498 result = IDirect3DDevice9_BeginScene(data->device);
501 return D3D_SetError(
"BeginScene()", result);
512 D3D_RenderData *
data;
515 D3DPRESENT_PARAMETERS pparams;
516 IDirect3DSwapChain9 *chain;
530 data = (D3D_RenderData *)
SDL_calloc(1,
sizeof(*data));
563 renderer->
info = D3D_RenderDriver.
info;
575 pparams.hDeviceWindow = windowinfo.
info.win.
window;
576 pparams.BackBufferWidth =
w;
577 pparams.BackBufferHeight =
h;
578 pparams.BackBufferCount = 1;
579 pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
581 if (window_flags &
SDL_WINDOW_FULLSCREEN && (window_flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP) {
582 pparams.Windowed =
FALSE;
583 pparams.BackBufferFormat = PixelFormatToD3DFMT(fullscreen_mode.
format);
584 pparams.FullScreen_RefreshRateInHz = fullscreen_mode.
refresh_rate;
586 pparams.Windowed =
TRUE;
587 pparams.BackBufferFormat = D3DFMT_UNKNOWN;
588 pparams.FullScreen_RefreshRateInHz = 0;
591 pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
593 pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
600 IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
602 device_flags = D3DCREATE_FPU_PRESERVE;
603 if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) {
604 device_flags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
606 device_flags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
610 device_flags |= D3DCREATE_MULTITHREADED;
613 result = IDirect3D9_CreateDevice(data->d3d, data->adapter,
615 pparams.hDeviceWindow,
617 &pparams, &data->device);
619 D3D_DestroyRenderer(renderer);
620 D3D_SetError(
"CreateDevice()", result);
625 result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);
627 D3D_DestroyRenderer(renderer);
628 D3D_SetError(
"GetSwapChain()", result);
631 result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);
633 IDirect3DSwapChain9_Release(chain);
634 D3D_DestroyRenderer(renderer);
635 D3D_SetError(
"GetPresentParameters()", result);
638 IDirect3DSwapChain9_Release(chain);
639 if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
642 data->pparams = pparams;
644 IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
647 if (caps.NumSimultaneousRTs >= 2) {
651 if (caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) {
652 data->enableSeparateAlphaBlend =
SDL_TRUE;
656 IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
657 data->currentRenderTarget =
NULL;
660 D3D_InitRenderState(data);
662 if (caps.MaxSimultaneousTextures >= 3)
664 #ifdef ASSEMBLE_SHADER 725 const char *shader_text =
727 "def c0, -0.0627451017, -0.501960814, -0.501960814, 1\n" 728 "def c1, 1.16400003, 0, 1.59599996, 0\n" 729 "def c2, 1.16400003, -0.391000003, -0.813000023, 0\n" 730 "def c3, 1.16400003, 2.01799989, 0, 0\n" 741 "add r0.xyz, r0, c0\n" 744 "dp2add r1.z, r0, c3, c3.z\n" 750 LPD3DXBUFFER pErrorMsgs;
751 LPDWORD shader_data =
NULL;
752 DWORD shader_size = 0;
753 result = D3DXAssembleShader(shader_text,
SDL_strlen(shader_text),
NULL,
NULL, 0, &pCode, &pErrorMsgs);
755 shader_data = (DWORD*)pCode->lpVtbl->GetBufferPointer(pCode);
756 shader_size = pCode->lpVtbl->GetBufferSize(pCode);
757 PrintShaderData(shader_data, shader_size);
759 const char *error = (
const char *)pErrorMsgs->lpVtbl->GetBufferPointer(pErrorMsgs);
763 const DWORD shader_data[] = {
764 0xffff0200, 0x05000051, 0xa00f0000, 0xbd808081, 0xbf008081, 0xbf008081,
765 0x3f800000, 0x05000051, 0xa00f0001, 0x3f94fdf4, 0x00000000, 0x3fcc49ba,
766 0x00000000, 0x05000051, 0xa00f0002, 0x3f94fdf4, 0xbec83127, 0xbf5020c5,
767 0x00000000, 0x05000051, 0xa00f0003, 0x3f94fdf4, 0x400126e9, 0x00000000,
768 0x00000000, 0x0200001f, 0x80000000, 0xb0030000, 0x0200001f, 0x80000000,
769 0x900f0000, 0x0200001f, 0x90000000, 0xa00f0800, 0x0200001f, 0x90000000,
770 0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000,
771 0xb0e40000, 0xa0e40800, 0x03000042, 0x800f0001, 0xb0e40000, 0xa0e40801,
772 0x03000042, 0x800f0002, 0xb0e40000, 0xa0e40802, 0x02000001, 0x80020000,
773 0x80000001, 0x02000001, 0x80040000, 0x80000002, 0x03000002, 0x80070000,
774 0x80e40000, 0xa0e40000, 0x03000008, 0x80010001, 0x80e40000, 0xa0e40001,
775 0x03000008, 0x80020001, 0x80e40000, 0xa0e40002, 0x0400005a, 0x80040001,
776 0x80e40000, 0xa0e40003, 0xa0aa0003, 0x02000001, 0x80080001, 0xa0ff0000,
777 0x03000005, 0x800f0000, 0x80e40001, 0x90e40000, 0x02000001, 0x800f0800,
778 0x80e40000, 0x0000ffff
781 if (shader_data !=
NULL) {
782 result = IDirect3DDevice9_CreatePixelShader(data->device, shader_data, &data->ps_yuv);
787 D3D_SetError(
"CreatePixelShader()", result);
798 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
805 static D3DTEXTUREFILTERTYPE
810 if (!hint || *hint ==
'0' ||
SDL_strcasecmp(hint,
"nearest") == 0) {
811 return D3DTEXF_POINT;
813 return D3DTEXF_LINEAR;
825 texture->usage =
usage;
828 result = IDirect3DDevice9_CreateTexture(device, w, h, 1, usage,
829 PixelFormatToD3DFMT(format),
830 D3DPOOL_DEFAULT, &texture->texture,
NULL);
832 return D3D_SetError(
"CreateTexture(D3DPOOL_DEFAULT)", result);
843 if (texture->staging ==
NULL) {
844 result = IDirect3DDevice9_CreateTexture(device, texture->w, texture->h, 1, 0,
845 PixelFormatToD3DFMT(texture->format),
846 D3DPOOL_SYSTEMMEM, &texture->staging,
NULL);
848 return D3D_SetError(
"CreateTexture(D3DPOOL_SYSTEMMEM)", result);
859 if (texture->dirty && texture->staging) {
860 if (!texture->texture) {
861 result = IDirect3DDevice9_CreateTexture(device, texture->w, texture->h, 1, texture->usage,
862 PixelFormatToD3DFMT(texture->format), D3DPOOL_DEFAULT, &texture->texture,
NULL);
864 return D3D_SetError(
"CreateTexture(D3DPOOL_DEFAULT)", result);
868 result = IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)texture->staging, (IDirect3DBaseTexture9 *)texture->texture);
870 return D3D_SetError(
"UpdateTexture()", result);
874 result = IDirect3DDevice9_SetTexture(device, sampler, (IDirect3DBaseTexture9 *)texture->texture);
876 return D3D_SetError(
"SetTexture()", result);
884 if (texture->texture) {
885 IDirect3DTexture9_Release(texture->texture);
886 texture->texture =
NULL;
888 if (texture->staging) {
889 IDirect3DTexture9_AddDirtyRect(texture->staging,
NULL);
899 D3DLOCKED_RECT locked;
905 if (D3D_CreateStagingTexture(device, texture) < 0) {
910 d3drect.right = x +
w;
912 d3drect.bottom = y +
h;
914 result = IDirect3DTexture9_LockRect(texture->staging, 0, &locked, &d3drect, 0);
916 return D3D_SetError(
"LockRect()", result);
919 src = (
const Uint8 *)pixels;
922 if (length == pitch && length == locked.Pitch) {
925 if (length > pitch) {
928 if (length > locked.Pitch) {
929 length = locked.Pitch;
931 for (row = 0; row <
h; ++
row) {
937 result = IDirect3DTexture9_UnlockRect(texture->staging, 0);
939 return D3D_SetError(
"UnlockRect()", result);
947 D3D_DestroyTextureRep(D3D_TextureRep *texture)
949 if (texture->texture) {
950 IDirect3DTexture9_Release(texture->texture);
951 texture->texture =
NULL;
953 if (texture->staging) {
954 IDirect3DTexture9_Release(texture->staging);
955 texture->staging =
NULL;
962 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
963 D3D_TextureData *texturedata;
966 texturedata = (D3D_TextureData *)
SDL_calloc(1,
sizeof(*texturedata));
975 usage = D3DUSAGE_RENDERTARGET;
980 if (D3D_CreateTextureRep(data->device, &texturedata->texture, usage, texture->
format, texture->
w, texture->
h) < 0) {
988 if (D3D_CreateTextureRep(data->device, &texturedata->utexture, usage, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
992 if (D3D_CreateTextureRep(data->device, &texturedata->vtexture, usage, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
1002 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1003 D3D_TextureData *texturedata = (D3D_TextureData *)texture->
driverdata;
1009 if (D3D_RecreateTextureRep(data->device, &texturedata->texture, texture->
format, texture->
w, texture->
h) < 0) {
1013 if (texturedata->yuv) {
1014 if (D3D_RecreateTextureRep(data->device, &texturedata->utexture, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
1018 if (D3D_RecreateTextureRep(data->device, &texturedata->vtexture, texture->
format, texture->
w / 2, texture->
h / 2) < 0) {
1029 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1030 D3D_TextureData *texturedata = (D3D_TextureData *) texture->
driverdata;
1037 if (D3D_UpdateTextureRep(data->device, &texturedata->texture, texture->
format, rect->
x, rect->
y, rect->
w, rect->
h, pixels, pitch) < 0) {
1041 if (texturedata->yuv) {
1043 pixels = (
const void*)((
const Uint8*)pixels + rect->
h * pitch);
1045 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) {
1050 pixels = (
const void*)((
const Uint8*)pixels + (rect->
h * pitch)/4);
1051 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) {
1061 const Uint8 *Yplane,
int Ypitch,
1062 const Uint8 *Uplane,
int Upitch,
1063 const Uint8 *Vplane,
int Vpitch)
1065 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1066 D3D_TextureData *texturedata = (D3D_TextureData *) texture->
driverdata;
1073 if (D3D_UpdateTextureRep(data->device, &texturedata->texture, texture->
format, rect->
x, rect->
y, rect->
w, rect->
h, Yplane, Ypitch) < 0) {
1076 if (D3D_UpdateTextureRep(data->device, &texturedata->utexture, texture->
format, rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, Uplane, Upitch) < 0) {
1079 if (D3D_UpdateTextureRep(data->device, &texturedata->vtexture, texture->
format, rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, Vplane, Vpitch) < 0) {
1087 const SDL_Rect * rect,
void **pixels,
int *pitch)
1089 D3D_RenderData *data = (D3D_RenderData *)renderer->
driverdata;
1090 D3D_TextureData *texturedata = (D3D_TextureData *)texture->
driverdata;
1098 texturedata->locked_rect = *
rect;
1100 if (texturedata->yuv) {
1102 if (!texturedata->pixels) {
1103 texturedata->pitch = texture->
w;
1104 texturedata->pixels = (
Uint8 *)
SDL_malloc((texture->
h * texturedata->pitch * 3) / 2);
1105 if (!texturedata->pixels) {
1110 (
void *) ((
Uint8 *) texturedata->pixels + rect->
y * texturedata->pitch +
1112 *pitch = texturedata->pitch;
1115 D3DLOCKED_RECT locked;
1118 if (D3D_CreateStagingTexture(device, &texturedata->texture) < 0) {
1122 d3drect.left = rect->
x;
1123 d3drect.right = rect->
x + rect->
w;
1124 d3drect.top = rect->
y;
1125 d3drect.bottom = rect->
y + rect->
h;
1127 result = IDirect3DTexture9_LockRect(texturedata->texture.staging, 0, &locked, &d3drect, 0);
1129 return D3D_SetError(
"LockRect()", result);
1131 *pixels = locked.pBits;
1132 *pitch = locked.Pitch;
1141 D3D_TextureData *texturedata = (D3D_TextureData *)texture->
driverdata;
1147 if (texturedata->yuv) {
1148 const SDL_Rect *rect = &texturedata->locked_rect;
1150 (
void *) ((
Uint8 *) texturedata->pixels + rect->
y * texturedata->pitch +
1152 D3D_UpdateTexture(renderer, texture, rect, pixels, texturedata->pitch);
1154 IDirect3DTexture9_UnlockRect(texturedata->texture.staging, 0);
1155 texturedata->texture.dirty =
SDL_TRUE;
1162 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1163 D3D_TextureData *texturedata;
1164 D3D_TextureRep *texturerep;
1169 if (data->currentRenderTarget !=
NULL) {
1170 IDirect3DSurface9_Release(data->currentRenderTarget);
1171 data->currentRenderTarget =
NULL;
1174 if (texture ==
NULL) {
1175 IDirect3DDevice9_SetRenderTarget(data->device, 0, data->defaultRenderTarget);
1179 texturedata = (D3D_TextureData *)texture->
driverdata;
1186 texturerep = &texturedata->texture;
1187 if (texturerep->dirty && texturerep->staging) {
1188 if (!texturerep->texture) {
1189 result = IDirect3DDevice9_CreateTexture(device, texturerep->w, texturerep->h, 1, texturerep->usage,
1190 PixelFormatToD3DFMT(texturerep->format), D3DPOOL_DEFAULT, &texturerep->texture,
NULL);
1192 return D3D_SetError(
"CreateTexture(D3DPOOL_DEFAULT)", result);
1196 result = IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)texturerep->staging, (IDirect3DBaseTexture9 *)texturerep->texture);
1198 return D3D_SetError(
"UpdateTexture()", result);
1203 result = IDirect3DTexture9_GetSurfaceLevel(texturedata->texture.texture, 0, &data->currentRenderTarget);
1205 return D3D_SetError(
"GetSurfaceLevel()", result);
1207 result = IDirect3DDevice9_SetRenderTarget(data->device, 0, data->currentRenderTarget);
1209 return D3D_SetError(
"SetRenderTarget()", result);
1218 D3D_ActivateRenderer(renderer);
1220 return D3D_SetRenderTargetInternal(renderer, texture);
1226 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1237 IDirect3DDevice9_SetViewport(data->device, &
viewport);
1241 matrix.m[0][0] = 2.0f / renderer->
viewport.
w;
1242 matrix.m[0][1] = 0.0f;
1243 matrix.m[0][2] = 0.0f;
1244 matrix.m[0][3] = 0.0f;
1245 matrix.m[1][0] = 0.0f;
1246 matrix.m[1][1] = -2.0f / renderer->
viewport.
h;
1247 matrix.m[1][2] = 0.0f;
1248 matrix.m[1][3] = 0.0f;
1249 matrix.m[2][0] = 0.0f;
1250 matrix.m[2][1] = 0.0f;
1251 matrix.m[2][2] = 1.0f;
1252 matrix.m[2][3] = 0.0f;
1253 matrix.m[3][0] = -1.0f;
1254 matrix.m[3][1] = 1.0f;
1255 matrix.m[3][2] = 0.0f;
1256 matrix.m[3][3] = 1.0f;
1257 IDirect3DDevice9_SetTransform(data->device, D3DTS_PROJECTION, &matrix);
1266 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1273 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
TRUE);
1276 r.right = renderer->
viewport.
x + rect->
x + rect->
w;
1277 r.bottom = renderer->
viewport.
y + rect->
y + rect->
h;
1279 result = IDirect3DDevice9_SetScissorRect(data->device, &r);
1280 if (result != D3D_OK) {
1281 D3D_SetError(
"SetScissor()", result);
1285 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
FALSE);
1293 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1296 int BackBufferWidth, BackBufferHeight;
1298 if (D3D_ActivateRenderer(renderer) < 0) {
1302 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1305 BackBufferWidth = renderer->
target->
w;
1306 BackBufferHeight = renderer->
target->
h;
1308 BackBufferWidth = data->pparams.BackBufferWidth;
1309 BackBufferHeight = data->pparams.BackBufferHeight;
1313 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
FALSE);
1318 renderer->
viewport.
w == BackBufferWidth &&
1319 renderer->
viewport.
h == BackBufferHeight) {
1320 result = IDirect3DDevice9_Clear(data->device, 0,
NULL, D3DCLEAR_TARGET,
color, 0.0f, 0);
1327 viewport.Width = BackBufferWidth;
1328 viewport.Height = BackBufferHeight;
1329 viewport.MinZ = 0.0f;
1330 viewport.MaxZ = 1.0f;
1331 IDirect3DDevice9_SetViewport(data->device, &viewport);
1333 result = IDirect3DDevice9_Clear(data->device, 0,
NULL, D3DCLEAR_TARGET,
color, 0.0f, 0);
1340 viewport.MinZ = 0.0f;
1341 viewport.MaxZ = 1.0f;
1342 IDirect3DDevice9_SetViewport(data->device, &viewport);
1346 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE,
TRUE);
1350 return D3D_SetError(
"Clear()", result);
1356 D3D_SetBlendMode(D3D_RenderData * data,
int blendMode)
1358 switch (blendMode) {
1360 IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
1364 IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
1366 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
1368 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
1369 D3DBLEND_INVSRCALPHA);
1370 if (data->enableSeparateAlphaBlend) {
1371 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLENDALPHA,
1373 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLENDALPHA,
1374 D3DBLEND_INVSRCALPHA);
1378 IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
1380 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
1382 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
1384 if (data->enableSeparateAlphaBlend) {
1385 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLENDALPHA,
1387 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLENDALPHA,
1392 IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
1394 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
1396 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
1398 if (data->enableSeparateAlphaBlend) {
1399 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLENDALPHA,
1401 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLENDALPHA,
1412 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1418 if (D3D_ActivateRenderer(renderer) < 0) {
1422 D3D_SetBlendMode(data, renderer->
blendMode);
1425 IDirect3DDevice9_SetTexture(data->device, 0,
1426 (IDirect3DBaseTexture9 *) 0);
1428 return D3D_SetError(
"SetTexture()", result);
1431 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1434 for (i = 0; i <
count; ++
i) {
1435 vertices[
i].x = points[
i].
x;
1436 vertices[
i].y = points[
i].
y;
1437 vertices[
i].z = 0.0f;
1438 vertices[
i].color =
color;
1439 vertices[
i].u = 0.0f;
1440 vertices[
i].v = 0.0f;
1443 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, count,
1444 vertices,
sizeof(*vertices));
1447 return D3D_SetError(
"DrawPrimitiveUP()", result);
1456 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1462 if (D3D_ActivateRenderer(renderer) < 0) {
1466 D3D_SetBlendMode(data, renderer->
blendMode);
1469 IDirect3DDevice9_SetTexture(data->device, 0,
1470 (IDirect3DBaseTexture9 *) 0);
1472 return D3D_SetError(
"SetTexture()", result);
1475 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1478 for (i = 0; i <
count; ++
i) {
1479 vertices[
i].x = points[
i].
x;
1480 vertices[
i].y = points[
i].
y;
1481 vertices[
i].z = 0.0f;
1482 vertices[
i].color =
color;
1483 vertices[
i].u = 0.0f;
1484 vertices[
i].v = 0.0f;
1487 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_LINESTRIP, count-1,
1488 vertices,
sizeof(*vertices));
1493 points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
1494 vertices[0].x = points[count-1].
x;
1495 vertices[0].y = points[count-1].
y;
1496 result = IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, 1, vertices,
sizeof(*vertices));
1501 return D3D_SetError(
"DrawPrimitiveUP()", result);
1510 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1513 float minx, miny, maxx, maxy;
1517 if (D3D_ActivateRenderer(renderer) < 0) {
1521 D3D_SetBlendMode(data, renderer->
blendMode);
1524 IDirect3DDevice9_SetTexture(data->device, 0,
1525 (IDirect3DBaseTexture9 *) 0);
1527 return D3D_SetError(
"SetTexture()", result);
1530 color = D3DCOLOR_ARGB(renderer->
a, renderer->
r, renderer->
g, renderer->
b);
1532 for (i = 0; i <
count; ++
i) {
1537 maxx = rect->
x + rect->
w;
1538 maxy = rect->
y + rect->
h;
1540 vertices[0].x = minx;
1541 vertices[0].y = miny;
1542 vertices[0].z = 0.0f;
1543 vertices[0].color =
color;
1544 vertices[0].u = 0.0f;
1545 vertices[0].v = 0.0f;
1547 vertices[1].x = maxx;
1548 vertices[1].y = miny;
1549 vertices[1].z = 0.0f;
1550 vertices[1].color =
color;
1551 vertices[1].u = 0.0f;
1552 vertices[1].v = 0.0f;
1554 vertices[2].x = maxx;
1555 vertices[2].y = maxy;
1556 vertices[2].z = 0.0f;
1557 vertices[2].color =
color;
1558 vertices[2].u = 0.0f;
1559 vertices[2].v = 0.0f;
1561 vertices[3].x = minx;
1562 vertices[3].y = maxy;
1563 vertices[3].z = 0.0f;
1564 vertices[3].color =
color;
1565 vertices[3].u = 0.0f;
1566 vertices[3].v = 0.0f;
1569 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN,
1570 2, vertices,
sizeof(*vertices));
1572 return D3D_SetError(
"DrawPrimitiveUP()", result);
1579 D3D_UpdateTextureScaleMode(D3D_RenderData *data, D3D_TextureData *texturedata,
unsigned index)
1581 if (texturedata->scaleMode != data->scaleMode[index]) {
1582 IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MINFILTER,
1583 texturedata->scaleMode);
1584 IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MAGFILTER,
1585 texturedata->scaleMode);
1586 data->scaleMode[
index] = texturedata->scaleMode;
1594 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1595 D3D_TextureData *texturedata;
1597 float minx, miny, maxx, maxy;
1598 float minu, maxu, minv, maxv;
1603 if (D3D_ActivateRenderer(renderer) < 0) {
1607 texturedata = (D3D_TextureData *)texture->
driverdata;
1613 minx = dstrect->
x - 0.5f;
1614 miny = dstrect->
y - 0.5f;
1615 maxx = dstrect->
x + dstrect->
w - 0.5f;
1616 maxy = dstrect->
y + dstrect->
h - 0.5f;
1618 minu = (float) srcrect->
x / texture->
w;
1619 maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
1620 minv = (
float) srcrect->
y / texture->
h;
1621 maxv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
1623 color = D3DCOLOR_ARGB(texture->
a, texture->
r, texture->
g, texture->
b);
1625 vertices[0].x = minx;
1626 vertices[0].y = miny;
1627 vertices[0].z = 0.0f;
1628 vertices[0].color =
color;
1629 vertices[0].u = minu;
1630 vertices[0].v = minv;
1632 vertices[1].x = maxx;
1633 vertices[1].y = miny;
1634 vertices[1].z = 0.0f;
1635 vertices[1].color =
color;
1636 vertices[1].u = maxu;
1637 vertices[1].v = minv;
1639 vertices[2].x = maxx;
1640 vertices[2].y = maxy;
1641 vertices[2].z = 0.0f;
1642 vertices[2].color =
color;
1643 vertices[2].u = maxu;
1644 vertices[2].v = maxv;
1646 vertices[3].x = minx;
1647 vertices[3].y = maxy;
1648 vertices[3].z = 0.0f;
1649 vertices[3].color =
color;
1650 vertices[3].u = minu;
1651 vertices[3].v = maxv;
1653 D3D_SetBlendMode(data, texture->
blendMode);
1655 D3D_UpdateTextureScaleMode(data, texturedata, 0);
1657 if (D3D_BindTextureRep(data->device, &texturedata->texture, 0) < 0) {
1661 if (texturedata->yuv) {
1664 D3D_UpdateTextureScaleMode(data, texturedata, 1);
1665 D3D_UpdateTextureScaleMode(data, texturedata, 2);
1667 if (D3D_BindTextureRep(data->device, &texturedata->utexture, 1) < 0) {
1670 if (D3D_BindTextureRep(data->device, &texturedata->vtexture, 2) < 0) {
1676 result = IDirect3DDevice9_SetPixelShader(data->device,
shader);
1678 return D3D_SetError(
"SetShader()", result);
1682 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
1683 vertices,
sizeof(*vertices));
1685 return D3D_SetError(
"DrawPrimitiveUP()", result);
1688 result = IDirect3DDevice9_SetPixelShader(data->device,
NULL);
1690 return D3D_SetError(
"SetShader()", result);
1702 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1703 D3D_TextureData *texturedata;
1705 float minx, miny, maxx, maxy;
1706 float minu, maxu, minv, maxv;
1707 float centerx, centery;
1710 Float4X4 modelMatrix;
1713 if (D3D_ActivateRenderer(renderer) < 0) {
1717 texturedata = (D3D_TextureData *)texture->
driverdata;
1723 centerx = center->
x;
1724 centery = center->
y;
1727 minx = dstrect->
w - centerx - 0.5f;
1728 maxx = -centerx - 0.5f;
1731 minx = -centerx - 0.5f;
1732 maxx = dstrect->
w - centerx - 0.5f;
1736 miny = dstrect->
h - centery - 0.5f;
1737 maxy = -centery - 0.5f;
1740 miny = -centery - 0.5f;
1741 maxy = dstrect->
h - centery - 0.5f;
1744 minu = (float) srcrect->
x / texture->
w;
1745 maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
1746 minv = (
float) srcrect->
y / texture->
h;
1747 maxv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
1749 color = D3DCOLOR_ARGB(texture->
a, texture->
r, texture->
g, texture->
b);
1751 vertices[0].x = minx;
1752 vertices[0].y = miny;
1753 vertices[0].z = 0.0f;
1754 vertices[0].color =
color;
1755 vertices[0].u = minu;
1756 vertices[0].v = minv;
1758 vertices[1].x = maxx;
1759 vertices[1].y = miny;
1760 vertices[1].z = 0.0f;
1761 vertices[1].color =
color;
1762 vertices[1].u = maxu;
1763 vertices[1].v = minv;
1765 vertices[2].x = maxx;
1766 vertices[2].y = maxy;
1767 vertices[2].z = 0.0f;
1768 vertices[2].color =
color;
1769 vertices[2].u = maxu;
1770 vertices[2].v = maxv;
1772 vertices[3].x = minx;
1773 vertices[3].y = maxy;
1774 vertices[3].z = 0.0f;
1775 vertices[3].color =
color;
1776 vertices[3].u = minu;
1777 vertices[3].v = maxv;
1779 D3D_SetBlendMode(data, texture->
blendMode);
1782 modelMatrix = MatrixMultiply(
1783 MatrixRotationZ((
float)(M_PI * (
float) angle / 180.0
f)),
1784 MatrixTranslation(dstrect->
x + center->
x, dstrect->
y + center->
y, 0)
1786 IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)&modelMatrix);
1788 D3D_UpdateTextureScaleMode(data, texturedata, 0);
1790 if (D3D_BindTextureRep(data->device, &texturedata->texture, 0) < 0) {
1794 if (texturedata->yuv) {
1797 D3D_UpdateTextureScaleMode(data, texturedata, 1);
1798 D3D_UpdateTextureScaleMode(data, texturedata, 2);
1800 if (D3D_BindTextureRep(data->device, &texturedata->utexture, 1) < 0) {
1803 if (D3D_BindTextureRep(data->device, &texturedata->vtexture, 2) < 0) {
1809 result = IDirect3DDevice9_SetPixelShader(data->device,
shader);
1811 return D3D_SetError(
"SetShader()", result);
1815 IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
1816 vertices,
sizeof(*vertices));
1818 return D3D_SetError(
"DrawPrimitiveUP()", result);
1821 result = IDirect3DDevice9_SetPixelShader(data->device,
NULL);
1823 return D3D_SetError(
"SetShader()", result);
1827 modelMatrix = MatrixIdentity();
1828 IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)&modelMatrix);
1834 Uint32 format,
void * pixels,
int pitch)
1836 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1837 D3DSURFACE_DESC desc;
1838 LPDIRECT3DSURFACE9 backBuffer;
1839 LPDIRECT3DSURFACE9 surface;
1841 D3DLOCKED_RECT locked;
1844 if (data->currentRenderTarget) {
1845 backBuffer = data->currentRenderTarget;
1847 backBuffer = data->defaultRenderTarget;
1850 result = IDirect3DSurface9_GetDesc(backBuffer, &desc);
1852 IDirect3DSurface9_Release(backBuffer);
1853 return D3D_SetError(
"GetDesc()", result);
1856 result = IDirect3DDevice9_CreateOffscreenPlainSurface(data->device, desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surface,
NULL);
1858 IDirect3DSurface9_Release(backBuffer);
1859 return D3D_SetError(
"CreateOffscreenPlainSurface()", result);
1862 result = IDirect3DDevice9_GetRenderTargetData(data->device, backBuffer, surface);
1864 IDirect3DSurface9_Release(surface);
1865 IDirect3DSurface9_Release(backBuffer);
1866 return D3D_SetError(
"GetRenderTargetData()", result);
1869 d3drect.left = rect->
x;
1870 d3drect.right = rect->
x + rect->
w;
1871 d3drect.top = rect->
y;
1872 d3drect.bottom = rect->
y + rect->
h;
1874 result = IDirect3DSurface9_LockRect(surface, &locked, &d3drect, D3DLOCK_READONLY);
1876 IDirect3DSurface9_Release(surface);
1877 IDirect3DSurface9_Release(backBuffer);
1878 return D3D_SetError(
"LockRect()", result);
1882 D3DFMTToPixelFormat(desc.Format), locked.pBits, locked.Pitch,
1883 format, pixels, pitch);
1885 IDirect3DSurface9_UnlockRect(surface);
1887 IDirect3DSurface9_Release(surface);
1895 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1898 if (!data->beginScene) {
1899 IDirect3DDevice9_EndScene(data->device);
1903 result = IDirect3DDevice9_TestCooperativeLevel(data->device);
1904 if (result == D3DERR_DEVICELOST) {
1908 if (result == D3DERR_DEVICENOTRESET) {
1909 D3D_Reset(renderer);
1913 D3D_SetError(
"Present()", result);
1920 D3D_TextureData *data = (D3D_TextureData *) texture->
driverdata;
1925 D3D_DestroyTextureRep(&data->texture);
1926 D3D_DestroyTextureRep(&data->utexture);
1927 D3D_DestroyTextureRep(&data->vtexture);
1936 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1940 if (data->defaultRenderTarget) {
1941 IDirect3DSurface9_Release(data->defaultRenderTarget);
1942 data->defaultRenderTarget =
NULL;
1944 if (data->currentRenderTarget !=
NULL) {
1945 IDirect3DSurface9_Release(data->currentRenderTarget);
1946 data->currentRenderTarget =
NULL;
1949 IDirect3DPixelShader9_Release(data->ps_yuv);
1952 IDirect3DDevice9_Release(data->device);
1955 IDirect3D9_Release(data->d3d);
1971 #if SDL_VIDEO_RENDER_D3D && !SDL_RENDER_DISABLED 1972 D3D_RenderData *data = (D3D_RenderData *) renderer->
driverdata;
1980 device = data->device;
1982 IDirect3DDevice9_AddRef(device);
int(* RenderDrawLines)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
struct IDirect3D9 IDirect3D9
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
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
GLdouble GLdouble GLdouble r
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
GLint GLint GLint GLint GLint x
GLuint GLuint GLsizei count
#define SDL_HINT_RENDER_SCALE_QUALITY
A variable controlling the scaling quality.
static SDL_Window * window
GLenum GLenum GLuint texture
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Uint32 texture_formats[16]
The structure that defines a display mode.
#define SDL_GetWindowFlags
#define SDL_BYTESPERPIXEL(X)
int(* RenderFillRects)(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
uint32_t Uint32
An unsigned 32-bit integer type.
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
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
GLsizeiptr const void GLenum usage
void * SDL_calloc(size_t nmemb, size_t size)
#define SDL_GetWindowDisplayMode
GLint GLint GLint GLint GLint GLint y
static int GetScaleQuality(void)
static SDL_Renderer * renderer
uint8_t Uint8
An unsigned 8-bit integer type.
#define SDL_stack_alloc(type, count)
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* UpdateViewport)(SDL_Renderer *renderer)
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()
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)
The type used to identify a window.
SDL_Rect rects[MAX_RECTS]
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
Uint32 num_texture_formats
union SDL_SysWMinfo::@18 info
GLubyte GLubyte GLubyte GLubyte w
#define SDL_ConvertPixels
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
void(* RenderPresent)(SDL_Renderer *renderer)
#define SDL_stack_free(data)
GLuint GLsizei GLsizei * length
int(* UpdateClipRect)(SDL_Renderer *renderer)
GLfloat GLfloat GLfloat GLfloat h
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