This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_d3drender.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#if SDL_VIDEO_RENDER_D3D
#include "SDL_win32video.h"
/* Direct3D renderer implementation */
30
static SDL_Renderer *D3D_CreateRenderer(SDL_Window * window, Uint32 flags);
31
static int D3D_DisplayModeChanged(SDL_Renderer * renderer);
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
static int D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static int D3D_SetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture,
const SDL_Color * colors, int firstcolor,
int ncolors);
static int D3D_GetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture, SDL_Color * colors,
int firstcolor, int ncolors);
static int D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels,
int pitch);
static int D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, int markDirty,
void **pixels, int *pitch);
static void D3D_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static void D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
int numrects, const SDL_Rect * rects);
static int D3D_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 color);
static int D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect,
int blendMode, int scaleMode);
static void D3D_RenderPresent(SDL_Renderer * renderer);
static void D3D_DestroyTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
static void D3D_DestroyRenderer(SDL_Renderer * renderer);
SDL_RenderDriver D3D_RenderDriver = {
D3D_CreateRenderer,
64
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
65
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
66
67
68
69
70
71
72
SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_PRESENTVSYNC |
SDL_RENDERER_ACCELERATED),
(SDL_TEXTUREBLENDMODE_NONE | SDL_TEXTUREBLENDMODE_MASK |
SDL_TEXTUREBLENDMODE_BLEND | SDL_TEXTUREBLENDMODE_ADD |
SDL_TEXTUREBLENDMODE_MOD),
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_FAST |
SDL_TEXTURESCALEMODE_SLOW | SDL_TEXTURESCALEMODE_BEST),
75
76
77
78
79
80
81
82
83
84
85
86
SDL_PIXELFORMAT_INDEX8,
SDL_PIXELFORMAT_RGB332,
SDL_PIXELFORMAT_RGB444,
SDL_PIXELFORMAT_RGB555,
SDL_PIXELFORMAT_ARGB4444,
SDL_PIXELFORMAT_ARGB1555,
SDL_PIXELFORMAT_RGB565,
SDL_PIXELFORMAT_RGB888,
SDL_PIXELFORMAT_ARGB8888,
SDL_PIXELFORMAT_ARGB2101010,
SDL_PIXELFORMAT_UYVY,
SDL_PIXELFORMAT_YUY2},
87
88
89
90
91
92
93
0,
0}
};
typedef struct
{
IDirect3DDevice9 *device;
94
D3DPRESENT_PARAMETERS pparams;
95
SDL_bool beginScene;
96
} D3D_RenderData;
97
98
99
typedef struct
{
100
IDirect3DTexture9 *texture;
101
} D3D_TextureData;
103
104
105
typedef struct
{
float x, y, z;
106
107
float rhw;
float u, v;
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
static void
D3D_SetError(const char *prefix, HRESULT result)
{
const char *error;
switch (result) {
case D3DERR_WRONGTEXTUREFORMAT:
error = "WRONGTEXTUREFORMAT";
break;
case D3DERR_UNSUPPORTEDCOLOROPERATION:
error = "UNSUPPORTEDCOLOROPERATION";
break;
case D3DERR_UNSUPPORTEDCOLORARG:
error = "UNSUPPORTEDCOLORARG";
break;
case D3DERR_UNSUPPORTEDALPHAOPERATION:
error = "UNSUPPORTEDALPHAOPERATION";
break;
case D3DERR_UNSUPPORTEDALPHAARG:
error = "UNSUPPORTEDALPHAARG";
break;
case D3DERR_TOOMANYOPERATIONS:
error = "TOOMANYOPERATIONS";
break;
case D3DERR_CONFLICTINGTEXTUREFILTER:
error = "CONFLICTINGTEXTUREFILTER";
break;
case D3DERR_UNSUPPORTEDFACTORVALUE:
error = "UNSUPPORTEDFACTORVALUE";
break;
case D3DERR_CONFLICTINGRENDERSTATE:
error = "CONFLICTINGRENDERSTATE";
break;
case D3DERR_UNSUPPORTEDTEXTUREFILTER:
error = "UNSUPPORTEDTEXTUREFILTER";
break;
case D3DERR_CONFLICTINGTEXTUREPALETTE:
error = "CONFLICTINGTEXTUREPALETTE";
break;
case D3DERR_DRIVERINTERNALERROR:
error = "DRIVERINTERNALERROR";
break;
case D3DERR_NOTFOUND:
error = "NOTFOUND";
break;
case D3DERR_MOREDATA:
error = "MOREDATA";
break;
case D3DERR_DEVICELOST:
error = "DEVICELOST";
break;
case D3DERR_DEVICENOTRESET:
error = "DEVICENOTRESET";
break;
case D3DERR_NOTAVAILABLE:
error = "NOTAVAILABLE";
break;
case D3DERR_OUTOFVIDEOMEMORY:
error = "OUTOFVIDEOMEMORY";
break;
case D3DERR_INVALIDDEVICE:
error = "INVALIDDEVICE";
break;
case D3DERR_INVALIDCALL:
error = "INVALIDCALL";
break;
case D3DERR_DRIVERINVALIDCALL:
error = "DRIVERINVALIDCALL";
break;
case D3DERR_WASSTILLDRAWING:
error = "WASSTILLDRAWING";
break;
default:
error = "UNKNOWN";
break;
}
SDL_SetError("%s: %s", prefix, error);
187
fprintf(stderr, "%s: %s\n", prefix, error);
190
191
static D3DFORMAT
PixelFormatToD3DFMT(Uint32 format)
193
switch (format) {
194
case SDL_PIXELFORMAT_INDEX8:
195
return D3DFMT_P8;
196
case SDL_PIXELFORMAT_RGB332:
197
return D3DFMT_R3G3B2;
198
case SDL_PIXELFORMAT_RGB444:
199
return D3DFMT_X4R4G4B4;
200
case SDL_PIXELFORMAT_RGB555:
201
return D3DFMT_X1R5G5B5;
202
case SDL_PIXELFORMAT_ARGB4444:
203
return D3DFMT_A4R4G4B4;
204
case SDL_PIXELFORMAT_ARGB1555:
205
return D3DFMT_A1R5G5B5;
206
case SDL_PIXELFORMAT_RGB565:
207
return D3DFMT_R5G6B5;
208
case SDL_PIXELFORMAT_RGB888:
209
return D3DFMT_X8R8G8B8;
210
case SDL_PIXELFORMAT_ARGB8888:
211
return D3DFMT_A8R8G8B8;
212
case SDL_PIXELFORMAT_ARGB2101010:
213
return D3DFMT_A2R10G10B10;
214
case SDL_PIXELFORMAT_UYVY:
215
return D3DFMT_UYVY;
216
case SDL_PIXELFORMAT_YUY2:
217
218
219
220
return D3DFMT_YUY2;
default:
return D3DFMT_UNKNOWN;
}
221
222
223
224
225
226
227
228
}
void
D3D_AddRenderDriver(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
if (data->d3d) {
229
SDL_AddRenderDriver(0, &D3D_RenderDriver);
230
231
232
233
}
}
SDL_Renderer *
234
D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
235
236
237
238
239
{
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
SDL_VideoData *videodata = (SDL_VideoData *) display->device->driverdata;
SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata;
SDL_Renderer *renderer;
240
D3D_RenderData *data;
241
242
HRESULT result;
D3DPRESENT_PARAMETERS pparams;
243
IDirect3DSwapChain9 *chain;
244
D3DCAPS9 caps;
246
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
247
248
249
250
251
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
252
data = (D3D_RenderData *) SDL_calloc(1, sizeof(*data));
253
if (!data) {
254
D3D_DestroyRenderer(renderer);
255
256
257
258
SDL_OutOfMemory();
return NULL;
}
259
renderer->DisplayModeChanged = D3D_DisplayModeChanged;
260
261
262
263
264
265
266
267
268
269
270
271
272
renderer->CreateTexture = D3D_CreateTexture;
renderer->SetTexturePalette = D3D_SetTexturePalette;
renderer->GetTexturePalette = D3D_GetTexturePalette;
renderer->UpdateTexture = D3D_UpdateTexture;
renderer->LockTexture = D3D_LockTexture;
renderer->UnlockTexture = D3D_UnlockTexture;
renderer->DirtyTexture = D3D_DirtyTexture;
renderer->RenderFill = D3D_RenderFill;
renderer->RenderCopy = D3D_RenderCopy;
renderer->RenderPresent = D3D_RenderPresent;
renderer->DestroyTexture = D3D_DestroyTexture;
renderer->DestroyRenderer = D3D_DestroyRenderer;
renderer->info = D3D_RenderDriver.info;
273
274
275
renderer->window = window->id;
renderer->driverdata = data;
276
renderer->info.flags = SDL_RENDERER_ACCELERATED;
278
279
280
SDL_zero(pparams);
pparams.BackBufferWidth = window->w;
pparams.BackBufferHeight = window->h;
281
282
if (window->flags & SDL_WINDOW_FULLSCREEN) {
pparams.BackBufferFormat =
283
PixelFormatToD3DFMT(display->fullscreen_mode.format);
284
285
286
} else {
pparams.BackBufferFormat = D3DFMT_UNKNOWN;
}
287
if (flags & SDL_RENDERER_PRESENTFLIP2) {
288
289
pparams.BackBufferCount = 2;
pparams.SwapEffect = D3DSWAPEFFECT_FLIP;
290
} else if (flags & SDL_RENDERER_PRESENTFLIP3) {
291
292
pparams.BackBufferCount = 3;
pparams.SwapEffect = D3DSWAPEFFECT_FLIP;
293
} else if (flags & SDL_RENDERER_PRESENTCOPY) {
294
295
296
297
298
299
300
301
pparams.BackBufferCount = 1;
pparams.SwapEffect = D3DSWAPEFFECT_COPY;
} else {
pparams.BackBufferCount = 1;
pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
}
if (window->flags & SDL_WINDOW_FULLSCREEN) {
pparams.Windowed = FALSE;
302
pparams.FullScreen_RefreshRateInHz =
303
display->fullscreen_mode.refresh_rate;
304
305
} else {
pparams.Windowed = TRUE;
306
pparams.FullScreen_RefreshRateInHz = 0;
308
if (flags & SDL_RENDERER_PRESENTVSYNC) {
309
310
311
312
pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
} else {
pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
}
313
314
315
316
317
318
319
result = IDirect3D9_CreateDevice(videodata->d3d, D3DADAPTER_DEFAULT, /* FIXME */
D3DDEVTYPE_HAL,
windowdata->hwnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&pparams, &data->device);
if (FAILED(result)) {
320
D3D_DestroyRenderer(renderer);
321
322
323
324
325
D3D_SetError("CreateDevice()", result);
return NULL;
}
data->beginScene = SDL_TRUE;
326
327
328
/* Get presentation parameters to fill info */
result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);
if (FAILED(result)) {
329
D3D_DestroyRenderer(renderer);
330
331
332
333
334
335
D3D_SetError("GetSwapChain()", result);
return NULL;
}
result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);
if (FAILED(result)) {
IDirect3DSwapChain9_Release(chain);
336
D3D_DestroyRenderer(renderer);
337
338
339
340
341
342
D3D_SetError("GetPresentParameters()", result);
return NULL;
}
IDirect3DSwapChain9_Release(chain);
switch (pparams.SwapEffect) {
case D3DSWAPEFFECT_COPY:
343
renderer->info.flags |= SDL_RENDERER_PRESENTCOPY;
344
345
346
347
break;
case D3DSWAPEFFECT_FLIP:
switch (pparams.BackBufferCount) {
case 2:
348
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
349
350
break;
case 3:
351
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
352
353
354
355
break;
}
break;
case D3DSWAPEFFECT_DISCARD:
356
renderer->info.flags |= SDL_RENDERER_PRESENTDISCARD;
357
358
359
break;
}
if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
360
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
362
data->pparams = pparams;
364
365
366
IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
renderer->info.max_texture_width = caps.MaxTextureWidth;
renderer->info.max_texture_height = caps.MaxTextureHeight;
368
/* Set up parameters for rendering */
369
370
IDirect3DDevice9_SetVertexShader(data->device, NULL);
IDirect3DDevice9_SetFVF(data->device, D3DFVF_XYZRHW | D3DFVF_TEX1);
371
372
IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
D3DCULL_NONE);
373
IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
375
376
377
return renderer;
}
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
static int
D3D_Reset(SDL_Renderer * renderer)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
HRESULT result;
result = IDirect3DDevice9_Reset(data->device, &data->pparams);
if (FAILED(result)) {
if (result == D3DERR_DEVICELOST) {
/* Don't worry about it, we'll reset later... */
return 0;
} else {
D3D_SetError("Reset()", result);
return -1;
}
}
IDirect3DDevice9_SetVertexShader(data->device, NULL);
IDirect3DDevice9_SetFVF(data->device, D3DFVF_XYZRHW | D3DFVF_TEX1);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
return 0;
}
static int
D3D_DisplayModeChanged(SDL_Renderer * renderer)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
data->pparams.BackBufferWidth = window->w;
data->pparams.BackBufferHeight = window->h;
if (window->flags & SDL_WINDOW_FULLSCREEN) {
data->pparams.BackBufferFormat =
PixelFormatToD3DFMT(display->fullscreen_mode.format);
} else {
data->pparams.BackBufferFormat = D3DFMT_UNKNOWN;
}
return D3D_Reset(renderer);
}
421
D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
423
D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;
424
425
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
426
D3D_TextureData *data;
427
428
D3DPOOL pool;
HRESULT result;
430
data = (D3D_TextureData *) SDL_calloc(1, sizeof(*data));
431
432
433
434
435
436
437
if (!data) {
SDL_OutOfMemory();
return -1;
}
texture->driverdata = data;
438
439
440
441
442
443
#if 1
/* FIXME: Do we want non-managed textures?
They need to be freed on device reset and then reloaded by the app...
*/
texture->access = SDL_TEXTUREACCESS_LOCAL;
#endif
444
if (texture->access == SDL_TEXTUREACCESS_LOCAL) {
445
pool = D3DPOOL_MANAGED;
447
pool = D3DPOOL_DEFAULT;
449
450
451
452
453
454
455
456
457
458
459
result =
IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
texture->h, 1, 0,
PixelFormatToD3DFMT(texture->format),
pool, &data->texture, NULL);
if (FAILED(result)) {
D3D_SetError("CreateTexture()", result);
return -1;
}
return 0;
460
461
462
}
static int
463
464
D3D_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Color * colors, int firstcolor, int ncolors)
466
467
D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
470
471
472
}
static int
473
474
D3D_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
SDL_Color * colors, int firstcolor, int ncolors)
476
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
479
480
481
}
static int
482
483
D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
485
486
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;
487
488
489
490
491
492
493
IDirect3DTexture9 *temp;
RECT d3drect;
D3DLOCKED_RECT locked;
const Uint8 *src;
Uint8 *dst;
int row, length;
HRESULT result;
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
result =
IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
texture->h, 1, 0,
PixelFormatToD3DFMT(texture->format),
D3DPOOL_SYSTEMMEM, &temp, NULL);
if (FAILED(result)) {
D3D_SetError("CreateTexture()", result);
return -1;
}
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;
d3drect.bottom = rect->y + rect->h;
result = IDirect3DTexture9_LockRect(temp, 0, &locked, &d3drect, 0);
if (FAILED(result)) {
IDirect3DTexture9_Release(temp);
D3D_SetError("LockRect()", result);
return -1;
}
517
518
519
520
521
522
523
src = pixels;
dst = locked.pBits;
length = rect->w * SDL_BYTESPERPIXEL(texture->format);
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += pitch;
dst += locked.Pitch;
525
526
527
528
529
530
531
532
533
534
535
536
537
IDirect3DTexture9_UnlockRect(temp, 0);
result =
IDirect3DDevice9_UpdateTexture(renderdata->device,
(IDirect3DBaseTexture9 *) temp,
(IDirect3DBaseTexture9 *) data->
texture);
IDirect3DTexture9_Release(temp);
if (FAILED(result)) {
D3D_SetError("UpdateTexture()", result);
return -1;
}
return 0;
538
539
540
}
static int
541
542
543
D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch)
545
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
546
547
548
RECT d3drect;
D3DLOCKED_RECT locked;
HRESULT result;
550
if (texture->access != SDL_TEXTUREACCESS_LOCAL) {
551
552
553
554
555
556
557
558
559
560
561
562
563
564
SDL_SetError("Can't lock remote video memory");
return -1;
}
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;
d3drect.bottom = rect->y + rect->h;
result =
IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect,
markDirty ? 0 : D3DLOCK_NO_DIRTY_UPDATE);
if (FAILED(result)) {
D3D_SetError("LockRect()", result);
565
return -1;
567
568
569
*pixels = locked.pBits;
*pitch = locked.Pitch;
return 0;
570
571
572
}
static void
573
D3D_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
575
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
577
IDirect3DTexture9_UnlockRect(data->texture, 0);
578
579
580
}
static void
581
582
D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,
const SDL_Rect * rects)
584
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
585
586
587
588
589
590
591
592
593
594
595
596
597
RECT d3drect;
int i;
for (i = 0; i < numrects; ++i) {
const SDL_Rect *rect = &rects[i];
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;
d3drect.bottom = rect->y + rect->h;
IDirect3DTexture9_AddDirtyRect(data->texture, &d3drect);
}
598
599
600
}
static int
601
D3D_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color)
603
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
604
D3DRECT d3drect;
605
HRESULT result;
607
608
609
610
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
612
d3drect.x1 = rect->x;
613
d3drect.x2 = rect->x + rect->w;
614
d3drect.y1 = rect->y;
615
d3drect.y2 = rect->y + rect->h;
617
618
619
result =
IDirect3DDevice9_Clear(data->device, 1, &d3drect, D3DCLEAR_TARGET,
(D3DCOLOR) color, 1.0f, 0);
620
621
622
623
if (FAILED(result)) {
D3D_SetError("Clear()", result);
return -1;
}
624
625
626
627
return 0;
}
static int
628
629
630
D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect,
int blendMode, int scaleMode)
632
633
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
634
float minx, miny, maxx, maxy;
635
float minu, maxu, minv, maxv;
636
637
Vertex vertices[4];
HRESULT result;
639
640
641
642
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
644
645
646
647
minx = (float) dstrect->x - 0.5f;
miny = (float) dstrect->y - 0.5f;
maxx = (float) dstrect->x + dstrect->w - 0.5f;
maxy = (float) dstrect->y + dstrect->h - 0.5f;
649
650
651
652
minu = (float) srcrect->x / texture->w;
maxu = (float) (srcrect->x + srcrect->w) / texture->w;
minv = (float) srcrect->y / texture->h;
maxv = (float) (srcrect->y + srcrect->h) / texture->h;
653
654
655
656
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
657
658
659
660
vertices[0].rhw = 1.0f;
vertices[0].u = minu;
vertices[0].v = minv;
661
662
663
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
664
665
666
667
vertices[1].rhw = 1.0f;
vertices[1].u = maxu;
vertices[1].v = minv;
668
669
670
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
671
672
673
674
vertices[2].rhw = 1.0f;
vertices[2].u = maxu;
vertices[2].v = maxv;
675
676
677
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
678
679
680
vertices[3].rhw = 1.0f;
vertices[3].u = minu;
vertices[3].v = maxv;
682
switch (blendMode) {
683
case SDL_TEXTUREBLENDMODE_NONE:
684
685
686
IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
FALSE);
break;
687
688
case SDL_TEXTUREBLENDMODE_MASK:
case SDL_TEXTUREBLENDMODE_BLEND:
689
690
691
692
693
694
695
IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
TRUE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
D3DBLEND_SRCALPHA);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
D3DBLEND_INVSRCALPHA);
break;
696
case SDL_TEXTUREBLENDMODE_ADD:
697
698
699
700
701
702
703
IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
TRUE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
D3DBLEND_SRCALPHA);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
D3DBLEND_ONE);
break;
704
case SDL_TEXTUREBLENDMODE_MOD:
705
706
707
708
709
710
711
712
713
IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE,
TRUE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
D3DBLEND_ZERO);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
D3DBLEND_SRCCOLOR);
break;
}
714
switch (scaleMode) {
715
716
case SDL_TEXTURESCALEMODE_NONE:
case SDL_TEXTURESCALEMODE_FAST:
717
718
719
720
721
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_POINT);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_POINT);
break;
722
case SDL_TEXTURESCALEMODE_SLOW:
723
724
725
726
727
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_LINEAR);
break;
728
case SDL_TEXTURESCALEMODE_BEST:
729
730
731
732
733
734
735
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_GAUSSIANQUAD);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_GAUSSIANQUAD);
break;
}
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
result =
IDirect3DDevice9_SetTexture(data->device, 0,
(IDirect3DBaseTexture9 *) texturedata->
texture);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
751
752
753
754
return 0;
}
static void
755
D3D_RenderPresent(SDL_Renderer * renderer)
757
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
758
759
760
761
762
763
764
HRESULT result;
if (!data->beginScene) {
IDirect3DDevice9_EndScene(data->device);
data->beginScene = SDL_TRUE;
}
765
766
767
768
769
770
771
772
result = IDirect3DDevice9_TestCooperativeLevel(data->device);
if (result == D3DERR_DEVICELOST) {
/* We'll reset later */
return;
}
if (result == D3DERR_DEVICENOTRESET) {
D3D_Reset(renderer);
}
773
774
775
776
result = IDirect3DDevice9_Present(data->device, NULL, NULL, NULL, NULL);
if (FAILED(result)) {
D3D_SetError("Present()", result);
}
777
778
779
}
static void
780
D3D_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
782
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
783
784
785
786
if (!data) {
return;
}
787
788
789
if (data->texture) {
IDirect3DTexture9_Release(data->texture);
}
790
791
792
793
SDL_free(data);
texture->driverdata = NULL;
}
794
static void
795
D3D_DestroyRenderer(SDL_Renderer * renderer)
797
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
798
799
if (data) {
800
801
802
if (data->device) {
IDirect3DDevice9_Release(data->device);
}
803
804
805
806
807
808
809
810
SDL_free(data);
}
SDL_free(renderer);
}
#endif /* SDL_VIDEO_RENDER_D3D */
/* vi: set ts=4 sw=4 expandtab: */