Debian Codegraph @

src/win/d3d_disp.cpp

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * Direct3D display driver
12 *
13 * By Trent Gamblin.
14 *
15 */
16
17 #include <windows.h>
18
19 #include <string.h>
20 #include <stdio.h>
21 #include <process.h>
22 #include <math.h>
23
24 #include "allegro5/allegro.h"
25
26 #include "allegro5/system.h"
27 #include "allegro5/internal/aintern.h"
28 #include "allegro5/internal/aintern_bitmap.h"
29 #include "allegro5/internal/aintern_display.h"
30 #include "allegro5/internal/aintern_pixels.h"
31 #include "allegro5/internal/aintern_system.h"
32 #include "allegro5/internal/aintern_thread.h"
33 #include "allegro5/internal/aintern_tri_soft.h" // For ALLEGRO_VERTEX
34 #include "allegro5/internal/aintern_prim_soft.h"
35 #include "allegro5/internal/aintern_vector.h"
36 #include "allegro5/internal/aintern_wclipboard.h"
37 #include "allegro5/platform/aintwin.h"
38
39 #include "d3d.h"
40 #include "prim_directx_shader.inc"
41
42 // Based on the code in <VersionHelpers.h> but that header is not
43 // available on Windows 7 SDK and earlier.
44 static BOOL is_windows_vista_or_greater() {
45 OSVERSIONINFOEX info;
46 ULONGLONG mask = 0;
47 VER_SET_CONDITION(mask, VER_MAJORVERSION, VER_GREATER_EQUAL);
48 VER_SET_CONDITION(mask, VER_MINORVERSION, VER_GREATER_EQUAL);
49 VER_SET_CONDITION(mask, VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
50 memset(&info, 0, sizeof(info));
51 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
52 info.dwMajorVersion = 6;
53
54 return VerifyVersionInfo(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR, mask) != FALSE;
55 }
56
57 static void d3d_set_target_bitmap(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bitmap);
58 static void d3d_update_transformation(ALLEGRO_DISPLAY* disp, ALLEGRO_BITMAP *target);
59 static bool d3d_init_display();
60
61 // C++ needs to cast void pointers
62 #define get_extra(b) ((ALLEGRO_BITMAP_EXTRA_D3D *)\
63 (b->parent ? b->parent->extra : b->extra))
64
65 static const char* _al_d3d_module_name = "d3d9.dll";
66
67 ALLEGRO_DEBUG_CHANNEL("d3d")
68
69 static ALLEGRO_DISPLAY_INTERFACE *vt = 0;
70
71 static HMODULE _al_d3d_module = 0;
72
73 typedef LPDIRECT3D9 (WINAPI *DIRECT3DCREATE9PROC)(UINT);
74
75 static DIRECT3DCREATE9PROC _al_d3d_create = (DIRECT3DCREATE9PROC)NULL;
76
77 #ifdef ALLEGRO_CFG_D3D9EX
78 typedef HRESULT (WINAPI *DIRECT3DCREATE9EXPROC)(UINT, LPDIRECT3D9EX*);
79
80 static DIRECT3DCREATE9EXPROC _al_d3d_create_ex = (DIRECT3DCREATE9EXPROC)NULL;
81 #endif
82
83 LPDIRECT3D9 _al_d3d = 0;
84
85 static D3DPRESENT_PARAMETERS d3d_pp;
86
87 static HWND fullscreen_focus_window;
88 static bool ffw_set = false;
89
90 static bool d3d_can_wait_for_vsync;
91
92 static bool render_to_texture_supported = true;
93 static bool is_vista = false;
94 static int num_faux_fullscreen_windows = 0;
95 static bool already_fullscreen = false; /* real fullscreen */
96
97 static ALLEGRO_MUTEX *present_mutex;
98 ALLEGRO_MUTEX *_al_d3d_lost_device_mutex;
99
100 /*
101 * In the context of this file, legacy cards pretty much refer to older Intel cards.
102 * They are distinguished by three misfeatures:
103 * 1. They don't support shaders
104 * 2. They don't support custom vertices
105 * 3. DrawIndexedPrimitiveUP is broken
106 *
107 * Since shaders are used 100% of the time, this means that for these cards
108 * the incoming vertices are first converted into the vertex type that these cards
109 * can handle.
110 */
111 static bool use_fixed_pipeline = false;
112 static bool know_card_type = false;
113
114 static bool check_use_fixed_pipeline(LPDIRECT3DDEVICE9 device)
115 {
116 if (!know_card_type) {
117 ALLEGRO_CONFIG* sys_cfg = al_get_system_config();
118 const char* detection_setting = al_get_config_value(sys_cfg, "graphics", "prim_d3d_legacy_detection");
119 detection_setting = detection_setting ? detection_setting : "default";
120 if (strcmp(detection_setting, "default") == 0) {
121 D3DCAPS9 caps;
122 device->GetDeviceCaps(&caps);
123 if (caps.PixelShaderVersion < D3DPS_VERSION(2, 0))
124 use_fixed_pipeline = true;
125 } else if(strcmp(detection_setting, "force_legacy") == 0) {
126 use_fixed_pipeline = true;
127 } else if(strcmp(detection_setting, "force_modern") == 0) {
128 use_fixed_pipeline = false;
129 } else {
130 ALLEGRO_WARN("Invalid setting for prim_d3d_legacy_detection.\n");
131 use_fixed_pipeline = false;
132 }
133 if (use_fixed_pipeline) {
134 ALLEGRO_WARN("Your GPU is considered legacy! Some of the features of the primitives addon will be slower/disabled.\n");
135 }
136 know_card_type = true;
137 }
138 return use_fixed_pipeline;
139 }
140
141 static ALLEGRO_MUTEX *primitives_mutex;
142 static char *fixed_buffer = NULL;
143 static size_t fixed_buffer_size = 0;
144
145 #define FOURCC(c0, c1, c2, c3) ((int)(c0) | ((int)(c1) << 8) | ((int)(c2) << 16) | ((int)(c3) << 24))
146
147 /*
148 * These parameters cannot be gotten by the display thread because
149 * they're thread local. We get them in the calling thread first.
150 */
151 struct D3D_DISPLAY_PARAMETERS {
152 ALLEGRO_DISPLAY_D3D *display;
153 volatile bool init_failed;
154 HANDLE AckEvent;
155 int window_x, window_y;
156 /* Not owned. */
157 const char *window_title;
158 };
159
160
161 static int allegro_formats[] = {
162 ALLEGRO_PIXEL_FORMAT_ANY,
163 ALLEGRO_PIXEL_FORMAT_ANY_WITH_ALPHA,
164 ALLEGRO_PIXEL_FORMAT_ANY_NO_ALPHA,
165 ALLEGRO_PIXEL_FORMAT_ANY_15_NO_ALPHA,
166 ALLEGRO_PIXEL_FORMAT_ANY_16_WITH_ALPHA,
167 ALLEGRO_PIXEL_FORMAT_ANY_16_NO_ALPHA,
168 ALLEGRO_PIXEL_FORMAT_ANY_24_NO_ALPHA,
169 ALLEGRO_PIXEL_FORMAT_ANY_32_WITH_ALPHA,
170 ALLEGRO_PIXEL_FORMAT_ANY_32_NO_ALPHA,
171 ALLEGRO_PIXEL_FORMAT_XRGB_8888,
172 ALLEGRO_PIXEL_FORMAT_ARGB_8888,
173 //ALLEGRO_PIXEL_FORMAT_ARGB_4444, this format seems not to be allowed
174 ALLEGRO_PIXEL_FORMAT_RGB_565,
175 //ALLEGRO_PIXEL_FORMAT_ARGB_1555, this format seems not to be allowed
176 ALLEGRO_PIXEL_FORMAT_ABGR_F32,
177 ALLEGRO_PIXEL_FORMAT_SINGLE_CHANNEL_8,
178 ALLEGRO_PIXEL_FORMAT_COMPRESSED_RGBA_DXT1,
179 ALLEGRO_PIXEL_FORMAT_COMPRESSED_RGBA_DXT3,
180 ALLEGRO_PIXEL_FORMAT_COMPRESSED_RGBA_DXT5,
181 -1
182 };
183
184 /* Mapping of Allegro formats to D3D formats */
185 static int d3d_formats[] = {
186 ALLEGRO_PIXEL_FORMAT_ANY,
187 ALLEGRO_PIXEL_FORMAT_ANY_WITH_ALPHA,
188 ALLEGRO_PIXEL_FORMAT_ANY_NO_ALPHA,
189 ALLEGRO_PIXEL_FORMAT_ANY_15_NO_ALPHA,
190 ALLEGRO_PIXEL_FORMAT_ANY_16_WITH_ALPHA,
191 ALLEGRO_PIXEL_FORMAT_ANY_16_NO_ALPHA,
192 ALLEGRO_PIXEL_FORMAT_ANY_24_NO_ALPHA,
193 ALLEGRO_PIXEL_FORMAT_ANY_32_WITH_ALPHA,
194 ALLEGRO_PIXEL_FORMAT_ANY_32_NO_ALPHA,
195 D3DFMT_X8R8G8B8,
196 D3DFMT_A8R8G8B8,
197 //D3DFMT_A4R4G4B4,
198 D3DFMT_R5G6B5,
199 //D3DFMT_A1R5G5B5,
200 D3DFMT_A32B32G32R32F,
201 D3DFMT_L8,
202 FOURCC('D', 'X', 'T', '1'),
203 FOURCC('D', 'X', 'T', '3'),
204 FOURCC('D', 'X', 'T', '5'),
205 -1
206 };
207
208 static void (*d3d_release_callback)(ALLEGRO_DISPLAY *display) = NULL;
209 static void (*d3d_restore_callback)(ALLEGRO_DISPLAY *display) = NULL;
210
211 #define ERR(e) case e: return #e;
212 static char const *_al_d3d_error_string(HRESULT e)
213 {
214 switch (e) {
215 ERR(D3D_OK)
216 ERR(D3DERR_NOTAVAILABLE)
217 ERR(D3DERR_DEVICELOST)
218 ERR(D3DERR_INVALIDCALL)
219 ERR(D3DERR_OUTOFVIDEOMEMORY)
220 ERR(E_OUTOFMEMORY)
221 }
222 return "UNKNOWN";
223 }
224 #undef ERR
225
226 static D3DFORMAT d3d_get_depth_stencil_format(ALLEGRO_EXTRA_DISPLAY_SETTINGS *settings)
227 {
228 struct DEPTH_STENCIL_DESC {
229 int d;
230 int s;
231 D3DFORMAT format;
232 };
233
234 DEPTH_STENCIL_DESC formats[] = {
235 { 0, 0, (D3DFORMAT)0 },
236 { 32, 0, D3DFMT_D32 },
237 { 15, 1, D3DFMT_D15S1 },
238 { 24, 8, D3DFMT_D24S8 },
239 { 24, 0, D3DFMT_D24X8 },
240 { 24, 4, D3DFMT_D24X4S4 },
241 { 16, 0, D3DFMT_D16 },
242 { -1, -1, (D3DFORMAT)0 }
243 };
244
245
246 for (int i = 0; formats[i].d >= 0; i++) {
247 if (settings->settings[ALLEGRO_DEPTH_SIZE] == formats[i].d &&
248 settings->settings[ALLEGRO_STENCIL_SIZE] == formats[i].s)
249 return formats[i].format;
250 }
251
252 return (D3DFORMAT)0;
253 }
254
255 static void d3d_call_callbacks(_AL_VECTOR *v, ALLEGRO_DISPLAY *display)
256 {
257 int i;
258 for (i = 0; i < (int)v->_size; i++) {
259 void (**callback)(ALLEGRO_DISPLAY *) = (void (**)(ALLEGRO_DISPLAY *))_al_vector_ref(v, i);
260 (*callback)(display);
261 }
262 }
263
264 /* Function: al_set_d3d_device_release_callback
265 */
266 void al_set_d3d_device_release_callback(
267 void (*callback)(ALLEGRO_DISPLAY *display))
268 {
269 d3d_release_callback = callback;
270 }
271
272 /* Function: al_set_d3d_device_restore_callback
273 */
274 void al_set_d3d_device_restore_callback(
275 void (*callback)(ALLEGRO_DISPLAY *display))
276 {
277 d3d_restore_callback = callback;
278 }
279
280 bool _al_d3d_supports_separate_alpha_blend(ALLEGRO_DISPLAY *display)
281 {
282 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)display;
283 return d3d_disp->supports_separate_alpha_blend;
284 }
285
286 /* Function: al_have_d3d_non_pow2_texture_support
287 */
288 bool al_have_d3d_non_pow2_texture_support(void)
289 {
290 D3DCAPS9 caps;
291 int adapter = al_get_new_display_adapter();
292
293 if (!_al_d3d && !d3d_init_display())
294 return false;
295 if (adapter < 0)
296 adapter = 0;
297
298 /* This might have to change for multihead */
299 if (_al_d3d->GetDeviceCaps(adapter, D3DDEVTYPE_HAL, &caps) != D3D_OK) {
300 if (_al_d3d->GetDeviceCaps(adapter, D3DDEVTYPE_REF, &caps) != D3D_OK) {
301 return false;
302 }
303 }
304
305 if ((caps.TextureCaps & D3DPTEXTURECAPS_POW2) == 0) {
306 return true;
307 }
308
309 return false;
310 }
311
312 static int d3d_get_max_texture_size(int adapter)
313 {
314 D3DCAPS9 caps;
315
316 if (!_al_d3d && !d3d_init_display())
317 return -1;
318
319 if (_al_d3d->GetDeviceCaps(adapter, D3DDEVTYPE_HAL, &caps) != D3D_OK) {
320 if (_al_d3d->GetDeviceCaps(adapter, D3DDEVTYPE_REF, &caps) != D3D_OK) {
321 return -1;
322 }
323 }
324
325 return _ALLEGRO_MIN(caps.MaxTextureWidth, caps.MaxTextureHeight);
326 }
327
328 /* Function: al_have_d3d_non_square_texture_support
329 */
330 bool al_have_d3d_non_square_texture_support(void)
331 {
332 D3DCAPS9 caps;
333 int adapter = al_get_new_display_adapter();
334 if (!_al_d3d && !d3d_init_display())
335 return false;
336 if (adapter < 0)
337 adapter = 0;
338
339 /* This might have to change for multihead */
340 if (_al_d3d->GetDeviceCaps(adapter, D3DDEVTYPE_HAL, &caps) != D3D_OK) {
341 if (_al_d3d->GetDeviceCaps(adapter, D3DDEVTYPE_REF, &caps) != D3D_OK) {
342 return false;
343 }
344 }
345
346 if ((caps.TextureCaps & D3DPTEXTURECAPS_SQUAREONLY) == 0) {
347 return true;
348 }
349
350 return false;
351 }
352
353
354 int _al_pixel_format_to_d3d(int format)
355 {
356 int i;
357
358 for (i = 0; allegro_formats[i] >= 0; i++) {
359 if (!_al_pixel_format_is_real(allegro_formats[i]))
360 continue;
361 if (allegro_formats[i] == format) {
362 return d3d_formats[i];
363 }
364 }
365
366 //return D3DFMT_R5G6B5;
367 return -1;
368 }
369
370 int _al_d3d_format_to_allegro(int d3d_fmt)
371 {
372 int i;
373
374 for (i = 0; d3d_formats[i] >= 0; i++) {
375 if (!_al_pixel_format_is_real(allegro_formats[i]))
376 continue;
377 if (d3d_formats[i] == d3d_fmt) {
378 return allegro_formats[i];
379 }
380 }
381
382 return -1;
383 }
384
385 int _al_d3d_num_display_formats(void)
386 {
387 return sizeof(d3d_formats) / sizeof(d3d_formats[0]);
388 }
389
390 void _al_d3d_get_nth_format(int i, int *allegro, D3DFORMAT *d3d)
391 {
392 *allegro = allegro_formats[i];
393 *d3d = (D3DFORMAT)d3d_formats[i];
394 }
395
396 static void d3d_reset_state(ALLEGRO_DISPLAY_D3D *disp)
397 {
398 if (disp->device_lost)
399 return;
400
401 disp->blender_state_op = -1;
402 disp->blender_state_src = -1;
403 disp->blender_state_dst = -1;
404 disp->blender_state_alpha_op = -1;
405 disp->blender_state_alpha_src = -1;
406 disp->blender_state_alpha_dst = -1;
407
408 disp->scissor_state.bottom = -1;
409 disp->scissor_state.top = -1;
410 disp->scissor_state.left = -1;
411 disp->scissor_state.right = -1;
412
413 disp->device->SetRenderState(D3DRS_LIGHTING, FALSE);
414 disp->device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
415 disp->device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
416
417 _al_d3d_update_render_state((ALLEGRO_DISPLAY *)disp);
418 }
419
420 static bool d3d_display_mode_matches(D3DDISPLAYMODE *dm, int w, int h, int format, int refresh_rate)
421 {
422 if ((dm->Width == (unsigned int)w) &&
423 (dm->Height == (unsigned int)h) &&
424 ((!refresh_rate) || (dm->RefreshRate == (unsigned int)refresh_rate)) &&
425 ((int)dm->Format == (int)_al_pixel_format_to_d3d(format))) {
426 return true;
427 }
428 return false;
429 }
430
431 static bool d3d_check_mode(int w, int h, int format, int refresh_rate, UINT adapter)
432 {
433 UINT num_modes;
434 UINT i;
435 D3DDISPLAYMODE display_mode;
436
437 if (!_al_d3d && !d3d_init_display())
438 return false;
439
440 num_modes = _al_d3d->GetAdapterModeCount(adapter, (D3DFORMAT)_al_pixel_format_to_d3d(format));
441
442 for (i = 0; i < num_modes; i++) {
443 if (_al_d3d->EnumAdapterModes(adapter, (D3DFORMAT)_al_pixel_format_to_d3d(format), i, &display_mode) != D3D_OK) {
444 return false;
445 }
446 if (d3d_display_mode_matches(&display_mode, w, h, format, refresh_rate)) {
447 return true;
448 }
449 }
450
451 return false;
452 }
453
454 static int d3d_get_default_refresh_rate(UINT adapter)
455 {
456 D3DDISPLAYMODE d3d_dm;
457 if (!_al_d3d && !d3d_init_display())
458 return 0;
459 _al_d3d->GetAdapterDisplayMode(adapter, &d3d_dm);
460 return d3d_dm.RefreshRate;
461 }
462
463
464 static bool d3d_create_fullscreen_device(ALLEGRO_DISPLAY_D3D *d,
465 int format, int refresh_rate, int flags)
466 {
467 int ret;
468 bool reset_all = false;
469 ALLEGRO_DISPLAY_WIN *win_display = &d->win_display;
470 ALLEGRO_DISPLAY *al_display = &win_display->display;
471
472 (void)flags;
473
474 if (!d3d_check_mode(al_display->w, al_display->h, format, refresh_rate, win_display->adapter)) {
475 ALLEGRO_ERROR("d3d_create_fullscreen_device: Mode not supported.\n");
476 return 0;
477 }
478
479 ZeroMemory(&d3d_pp, sizeof(d3d_pp));
480 d3d_pp.BackBufferFormat = (D3DFORMAT)_al_pixel_format_to_d3d(format);
481 d3d_pp.BackBufferWidth = al_display->w;
482 d3d_pp.BackBufferHeight = al_display->h;
483 d3d_pp.BackBufferCount = 1;
484 d3d_pp.Windowed = 0;
485 if (d->vsync) {
486 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
487 }
488 else {
489 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
490 }
491
492 if (d->depth_stencil_format) {
493 d3d_pp.EnableAutoDepthStencil = true;
494 d3d_pp.AutoDepthStencilFormat = d->depth_stencil_format;
495 }
496 if (d->samples) {
497 d3d_pp.MultiSampleType = D3DMULTISAMPLE_NONMASKABLE;
498 d3d_pp.MultiSampleQuality = d->samples;
499 }
500 else
501 d3d_pp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
502
503 if (d->single_buffer) {
504 d3d_pp.SwapEffect = D3DSWAPEFFECT_COPY;
505 }
506 else {
507 d3d_pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
508 }
509 d3d_pp.hDeviceWindow = win_display->window;
510
511 if (refresh_rate) {
512 d3d_pp.FullScreen_RefreshRateInHz = refresh_rate;
513 }
514 else {
515 d3d_pp.FullScreen_RefreshRateInHz = d3d_get_default_refresh_rate(win_display->adapter);
516 al_display->refresh_rate = d3d_pp.FullScreen_RefreshRateInHz;
517 }
518
519 if (ffw_set == false) {
520 fullscreen_focus_window = win_display->window;
521 ffw_set = true;
522 }
523 else {
524 reset_all = true;
525 }
526
527 #ifdef ALLEGRO_CFG_D3D9EX
528 if (is_vista) {
529 D3DDISPLAYMODEEX mode;
530 IDirect3D9Ex *d3d = (IDirect3D9Ex *)_al_d3d;
531 mode.Size = sizeof(D3DDISPLAYMODEEX);
532 mode.Width = al_display->w;
533 mode.Height = al_display->h;
534 mode.RefreshRate = d3d_pp.FullScreen_RefreshRateInHz;
535 mode.Format = d3d_pp.BackBufferFormat;
536 mode.ScanLineOrdering = D3DSCANLINEORDERING_PROGRESSIVE;
537
538 if ((ret = d3d->CreateDeviceEx(win_display->adapter,
539 D3DDEVTYPE_HAL, fullscreen_focus_window,
540 D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED|D3DCREATE_SCREENSAVER,
541 &d3d_pp, &mode, (IDirect3DDevice9Ex **)(&d->device))) != D3D_OK) {
542 if ((ret = d3d->CreateDeviceEx(win_display->adapter,
543 D3DDEVTYPE_HAL, fullscreen_focus_window,
544 D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED|D3DCREATE_SCREENSAVER,
545 &d3d_pp, &mode, (IDirect3DDevice9Ex **)(&d->device))) != D3D_OK) {
546 if ((ret = d3d->CreateDeviceEx(win_display->adapter,
547 D3DDEVTYPE_REF, fullscreen_focus_window,
548 D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED|D3DCREATE_SCREENSAVER,
549 &d3d_pp, &mode, (IDirect3DDevice9Ex **)(&d->device))) != D3D_OK) {
550 if ((ret = d3d->CreateDeviceEx(win_display->adapter,
551 D3DDEVTYPE_REF, fullscreen_focus_window,
552 D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED|D3DCREATE_SCREENSAVER,
553 &d3d_pp, &mode, (IDirect3DDevice9Ex **)(&d->device))) != D3D_OK) {
554 switch (ret) {
555 case D3DERR_INVALIDCALL:
556 ALLEGRO_ERROR("D3DERR_INVALIDCALL in create_device.\n");
557 break;
558 case D3DERR_NOTAVAILABLE:
559 ALLEGRO_ERROR("D3DERR_NOTAVAILABLE in create_device.\n");
560 break;
561 case D3DERR_OUTOFVIDEOMEMORY:
562 ALLEGRO_ERROR("D3DERR_OUTOFVIDEOMEMORY in create_device.\n");
563 break;
564 case D3DERR_DEVICELOST:
565 ALLEGRO_ERROR("D3DERR_DEVICELOST in create_device.\n");
566 break;
567 default:
568 ALLEGRO_ERROR("Direct3D Device creation failed.\n");
569 break;
570 }
571 return 0;
572 } }
573 }
574 }
575 }
576 else
577 #endif
578 {
579 if ((ret = _al_d3d->CreateDevice(win_display->adapter,
580 D3DDEVTYPE_HAL, fullscreen_focus_window,
581 D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
582 &d3d_pp, &d->device)) != D3D_OK) {
583 if ((ret = _al_d3d->CreateDevice(win_display->adapter,
584 D3DDEVTYPE_HAL, fullscreen_focus_window,
585 D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
586 &d3d_pp, &d->device)) != D3D_OK) {
587 if ((ret = _al_d3d->CreateDevice(win_display->adapter,
588 D3DDEVTYPE_REF, fullscreen_focus_window,
589 D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
590 &d3d_pp, &d->device)) != D3D_OK) {
591 if ((ret = _al_d3d->CreateDevice(win_display->adapter,
592 D3DDEVTYPE_REF, fullscreen_focus_window,
593 D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
594 &d3d_pp, &d->device)) != D3D_OK) {
595 switch (ret) {
596 case D3DERR_INVALIDCALL:
597 ALLEGRO_ERROR("D3DERR_INVALIDCALL in create_device.\n");
598 break;
599 case D3DERR_NOTAVAILABLE:
600 ALLEGRO_ERROR("D3DERR_NOTAVAILABLE in create_device.\n");
601 break;
602 case D3DERR_OUTOFVIDEOMEMORY:
603 ALLEGRO_ERROR("D3DERR_OUTOFVIDEOMEMORY in create_device.\n");
604 break;
605 case D3DERR_DEVICELOST:
606 ALLEGRO_ERROR("D3DERR_DEVICELOST in create_device.\n");
607 break;
608 default:
609 ALLEGRO_ERROR("Direct3D Device creation failed.\n");
610 break;
611 }
612 return 0;
613 }
614 }
615 }
616 }
617 }
618
619 d->device->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &d->render_target);
620
621 ALLEGRO_INFO("Fullscreen Direct3D device created.\n");
622
623 d->device->BeginScene();
624
625 ALLEGRO_SYSTEM *system = (ALLEGRO_SYSTEM *)al_get_system_driver();
626
627 if (reset_all) {
628 int i;
629 for (i = 0; i < (int)system->displays._size; i++) {
630 ALLEGRO_DISPLAY_D3D **dptr = (ALLEGRO_DISPLAY_D3D **)_al_vector_ref(&system->displays, i);
631 ALLEGRO_DISPLAY_D3D *disp = *dptr;
632 if (disp != d) {
633 if (disp != d && (disp->win_display.display.flags & ALLEGRO_FULLSCREEN)) {
634 disp->do_reset = true;
635 while (!disp->reset_done) {
636 al_rest(0.001);
637 }
638 disp->reset_done = false;
639 }
640 }
641 }
642 }
643
644 return 1;
645 }
646
647 static void d3d_destroy_device(ALLEGRO_DISPLAY_D3D *disp)
648 {
649 while (disp->device->Release() != 0) {
650 ALLEGRO_WARN("d3d_destroy_device: ref count not 0\n");
651 }
652 disp->device = NULL;
653 }
654
655
656 bool _al_d3d_render_to_texture_supported(void)
657 {
658 return render_to_texture_supported;
659 }
660
661
662
663 static bool d3d_init_display()
664 {
665 D3DDISPLAYMODE d3d_dm;
666
667 _al_d3d_module = _al_win_safe_load_library(_al_d3d_module_name);
668 if (_al_d3d_module == NULL) {
669 ALLEGRO_ERROR("Failed to open '%s' library\n", _al_d3d_module_name);
670 return false;
671 }
672
673 #ifdef ALLEGRO_CFG_D3DX9
674 _al_load_d3dx9_module();
675 #endif
676
677 is_vista = is_windows_vista_or_greater();
678
679 #ifdef ALLEGRO_CFG_D3D9EX
680 if (is_vista) {
681 _al_d3d_create_ex = (DIRECT3DCREATE9EXPROC)GetProcAddress(_al_d3d_module, "Direct3DCreate9Ex");
682 if (_al_d3d_create_ex != NULL) {
683 if (_al_d3d_create_ex(D3D_SDK_VERSION, (LPDIRECT3D9EX *)&_al_d3d) != D3D_OK) {
684 ALLEGRO_ERROR("Direct3DCreate9Ex failed\n");
685 FreeLibrary(_al_d3d_module);
686 return false;
687 }
688 }
689 else {
690 ALLEGRO_INFO("Direct3DCreate9Ex not in %s\n", _al_d3d_module_name);
691 is_vista = false;
692 }
693 }
694
695 if (!is_vista)
696 #endif
697 {
698 _al_d3d_create = (DIRECT3DCREATE9PROC)GetProcAddress(_al_d3d_module, "Direct3DCreate9");
699 if (_al_d3d_create != NULL) {
700 if ((_al_d3d = _al_d3d_create(D3D9b_SDK_VERSION)) == NULL) {
701 ALLEGRO_ERROR("Direct3DCreate9 failed.\n");
702 FreeLibrary(_al_d3d_module);
703 return false;
704 }
705 }
706 else {
707 ALLEGRO_ERROR("Direct3DCreate9 not in %s\n", _al_d3d_module_name);
708 FreeLibrary(_al_d3d_module);
709 return false;
710 }
711 }
712
713 _al_d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3d_dm);
714
715 if (_al_d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT,
716 D3DDEVTYPE_HAL, d3d_dm.Format, D3DUSAGE_RENDERTARGET,
717 D3DRTYPE_TEXTURE, d3d_dm.Format) != D3D_OK) {
718 if (_al_d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT,
719 D3DDEVTYPE_REF, d3d_dm.Format, D3DUSAGE_RENDERTARGET,
720 D3DRTYPE_TEXTURE, d3d_dm.Format) != D3D_OK) {
721 render_to_texture_supported = false;
722 }
723 else
724 render_to_texture_supported = true;
725 }
726 else
727 render_to_texture_supported = true;
728
729
730 ALLEGRO_INFO("Render-to-texture: %d\n", render_to_texture_supported);
731
732 present_mutex = al_create_mutex();
733 _al_d3d_lost_device_mutex = al_create_mutex();
734 primitives_mutex = al_create_mutex();
735
736 #ifdef ALLEGRO_CFG_SHADER_HLSL
737 _al_d3d_init_shaders();
738 #endif
739
740 return true;
741 }
742
743
744 static ALLEGRO_DISPLAY_D3D *d3d_create_display_internals(ALLEGRO_DISPLAY_D3D *d3d_display, bool free_on_error);
745 static void d3d_destroy_display_internals(ALLEGRO_DISPLAY_D3D *display);
746
747
748 static void d3d_make_faux_fullscreen_stage_one(ALLEGRO_DISPLAY_D3D *d3d_display)
749 {
750 ALLEGRO_SYSTEM *system = al_get_system_driver();
751
752 if (already_fullscreen || num_faux_fullscreen_windows) {
753 int i;
754 for (i = 0; i < (int)system->displays._size; i++) {
755 ALLEGRO_DISPLAY_D3D **dptr = (ALLEGRO_DISPLAY_D3D **)_al_vector_ref(&system->displays, i);
756 ALLEGRO_DISPLAY_D3D *disp = *dptr;
757 if (disp != d3d_display) {// && (disp->win_display.display.flags & ALLEGRO_FULLSCREEN)) {
758 d3d_destroy_display_internals(disp);
759 disp->win_display.end_thread = false;
760 disp->win_display.thread_ended = false;
761 }
762 }
763 }
764 }
765
766
767 static void d3d_make_faux_fullscreen_stage_two(ALLEGRO_DISPLAY_D3D *d3d_display)
768 {
769 ALLEGRO_SYSTEM *system = al_get_system_driver();
770
771 if (already_fullscreen || num_faux_fullscreen_windows) {
772 int i;
773 already_fullscreen = false;
774 for (i = 0; i < (int)system->displays._size; i++) {
775 ALLEGRO_DISPLAY_D3D **dptr = (ALLEGRO_DISPLAY_D3D **)_al_vector_ref(&system->displays, i);
776 ALLEGRO_DISPLAY_D3D *disp = *dptr;
777 if (disp != d3d_display) {// && (disp->win_display.display.flags & ALLEGRO_FULLSCREEN)) {
778 if (disp->win_display.display.flags & ALLEGRO_FULLSCREEN)
779 disp->faux_fullscreen = true;
780 disp = d3d_create_display_internals(disp, true);
781 if (!disp) {
782 ALLEGRO_ERROR("d3d_create_display_internals failed.\n");
783 /* XXX we don't try to recover from this yet */
784 abort();
785 }
786 ASSERT(disp);
787 _al_d3d_recreate_bitmap_textures(disp);
788 }
789 }
790 }
791 }
792
793 static bool d3d_create_device(ALLEGRO_DISPLAY_D3D *d,
794 int format, int refresh_rate, int flags, bool convert_to_faux)
795 {
796 HRESULT hr;
797 ALLEGRO_DISPLAY_WIN *win_display = &d->win_display;
798 ALLEGRO_DISPLAY *al_display = &win_display->display;
799 int adapter = win_display->adapter;
800
801 (void)refresh_rate;
802 (void)flags;
803
804 /* Ideally if you're targetting vanilla Direct3D 9 you should create
805 * your windowed displays before any fullscreen ones. If you don't,
806 * your fullscreen displays will be turned into "faux-fullscreen"
807 * displays, basically screen-filling windows set out in front of
808 * everything else.
809 */
810 #ifdef ALLEGRO_CFG_D3D9EX
811 if (convert_to_faux)
812 d3d_make_faux_fullscreen_stage_one(d);
813 #else
814 (void)convert_to_faux;
815 #endif
816
817 ZeroMemory(&d3d_pp, sizeof(d3d_pp));
818
819 d3d_pp.BackBufferFormat = (D3DFORMAT)_al_pixel_format_to_d3d(format);
820
821 d3d_pp.BackBufferWidth = al_display->w;
822 d3d_pp.BackBufferHeight = al_display->h;
823 d3d_pp.BackBufferCount = 1;
824 d3d_pp.Windowed = 1;
825 if (d->vsync) {
826 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
827 }
828 else {
829 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
830 }
831
832 if (d->depth_stencil_format) {
833 d3d_pp.EnableAutoDepthStencil = true;
834 d3d_pp.AutoDepthStencilFormat = d->depth_stencil_format;
835 ALLEGRO_INFO("Chose depth stencil format %d\n", d->depth_stencil_format);
836 }
837 else {
838 ALLEGRO_INFO("Using no depth stencil buffer\n");
839 }
840
841 if (d->samples) {
842 d3d_pp.MultiSampleType = D3DMULTISAMPLE_NONMASKABLE;
843 d3d_pp.MultiSampleQuality = d->samples;
844 }
845 else
846 d3d_pp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
847
848 if (d->single_buffer) {
849 d3d_pp.SwapEffect = D3DSWAPEFFECT_COPY;
850 }
851 else {
852 d3d_pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
853 }
854 d3d_pp.hDeviceWindow = win_display->window;
855
856 if (!refresh_rate) {
857 al_display->refresh_rate = d3d_get_default_refresh_rate(win_display->adapter);
858 }
859
860 if (adapter < 0)
861 adapter = 0;
862
863 if ((hr = _al_d3d->CreateDevice(adapter,
864 D3DDEVTYPE_HAL, win_display->window,
865 D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
866 &d3d_pp, (LPDIRECT3DDEVICE9 *)&d->device)) != D3D_OK) {
867 ALLEGRO_DEBUG("trying D3DCREATE_SOFTWARE_VERTEXPROCESSING\n");
868 if ((hr = _al_d3d->CreateDevice(adapter,
869 D3DDEVTYPE_HAL, win_display->window,
870 D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
871 &d3d_pp, (LPDIRECT3DDEVICE9 *)&d->device)) != D3D_OK) {
872 ALLEGRO_DEBUG("trying D3DDEVTYPE_REF\n");
873 if ((hr = _al_d3d->CreateDevice(adapter,
874 D3DDEVTYPE_REF, win_display->window,
875 D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
876 &d3d_pp, (LPDIRECT3DDEVICE9 *)&d->device)) != D3D_OK) {
877 ALLEGRO_DEBUG("trying D3DDEVTYPE_REF|D3DCREATE_SOFTWARE_VERTEXPROCESSING\n");
878 if ((hr = _al_d3d->CreateDevice(adapter,
879 D3DDEVTYPE_REF, win_display->window,
880 D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_FPU_PRESERVE|D3DCREATE_MULTITHREADED,
881 &d3d_pp, (LPDIRECT3DDEVICE9 *)&d->device)) != D3D_OK) {
882
883 ALLEGRO_ERROR("CreateDevice failed: %s\n", _al_d3d_error_string(hr));
884 return 0;
885 }
886 }
887 }
888 }
889
890 if (d->device->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &d->render_target) != D3D_OK) {
891 //if (d->device->GetRenderTarget(0, &d->render_target) != D3D_OK) {
892 ALLEGRO_ERROR("d3d_create_device: GetBackBuffer failed.\n");
893 return 0;
894 }
895
896 if (d->device->BeginScene() != D3D_OK) {
897 ALLEGRO_ERROR("BeginScene failed in create_device\n");
898 }
899 else {
900 ALLEGRO_DEBUG("BeginScene succeeded in create_device\n");
901 }
902
903 #ifdef ALLEGRO_CFG_D3D9EX
904 if (convert_to_faux)
905 d3d_make_faux_fullscreen_stage_two(d);
906 #endif
907
908 ALLEGRO_DEBUG("Success\n");
909
910 return 1;
911 }
912
913 /* When a display is destroyed, its bitmaps get converted
914 * to memory bitmaps
915 */
916 static void d3d_release_bitmaps(ALLEGRO_DISPLAY *display)
917 {
918 while (display->bitmaps._size > 0) {
919 ALLEGRO_BITMAP **bptr = (ALLEGRO_BITMAP **)_al_vector_ref_back(&display->bitmaps);
920 ALLEGRO_BITMAP *b = *bptr;
921 _al_convert_to_memory_bitmap(b);
922 }
923 }
924
925
926 static void d3d_destroy_display_internals(ALLEGRO_DISPLAY_D3D *d3d_display)
927 {
928 ALLEGRO_DISPLAY *al_display = (ALLEGRO_DISPLAY *)d3d_display;
929 ALLEGRO_DISPLAY_WIN *win_display = &d3d_display->win_display;
930
931 if (d3d_display->device) {
932 #ifdef ALLEGRO_CFG_SHADER_HLSL
933 _al_remove_display_invalidated_callback(al_display, _al_d3d_on_lost_shaders);
934 _al_remove_display_validated_callback(al_display, _al_d3d_on_reset_shaders);
935 #endif
936 d3d_call_callbacks(&al_display->display_invalidated_callbacks, al_display);
937 #ifdef ALLEGRO_CFG_SHADER_HLSL
938 _al_add_display_invalidated_callback(al_display, _al_d3d_on_lost_shaders);
939 _al_add_display_validated_callback(al_display, _al_d3d_on_reset_shaders);
940 #endif
941 d3d_display->device->EndScene();
942 }
943
944 d3d_release_bitmaps((ALLEGRO_DISPLAY *)d3d_display);
945 if (d3d_display->loop_index_buffer)
946 d3d_display->loop_index_buffer->Release();
947
948 ALLEGRO_DEBUG("waiting for display %p's thread to end\n", d3d_display);
949 if (win_display->window) {
950 SendMessage(win_display->window, _al_win_msg_suicide, 0, 0);
951 while (!win_display->thread_ended)
952 al_rest(0.001);
953 }
954
955 ASSERT(al_display->vt);
956 }
957
958 static void d3d_destroy_display(ALLEGRO_DISPLAY *display)
959 {
960 ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver();
961 ALLEGRO_DISPLAY_D3D *d3d_display = (ALLEGRO_DISPLAY_D3D *)display;
962 ALLEGRO_DISPLAY *old_disp = al_get_current_display();
963
964 ALLEGRO_INFO("destroying display %p (current %p)\n", display, old_disp);
965
966 if (old_disp != display)
967 _al_set_current_display_only(display);
968
969 if (system->mouse_grab_display == display)
970 al_ungrab_mouse();
971
972 _al_win_destroy_display_icons(display);
973
974 d3d_destroy_display_internals(d3d_display);
975
976 _al_vector_free(&display->display_invalidated_callbacks);
977 _al_vector_free(&display->display_validated_callbacks);
978
979 _al_vector_find_and_delete(&system->system.displays, &display);
980
981 if (system->system.displays._size <= 0) {
982 ffw_set = false;
983 already_fullscreen = false;
984 }
985
986 if (d3d_display->es_inited) {
987 _al_event_source_free(&display->es);
988 d3d_display->es_inited = false;
989 }
990
991 _al_vector_free(&display->bitmaps);
992 _al_vector_free(&((ALLEGRO_DISPLAY_WIN*) display)->msg_callbacks);
993
994 if (old_disp != display)
995 _al_set_current_display_only(old_disp);
996
997 al_free(display->vertex_cache);
998 al_free(display);
999 }
1000
1001 void _al_d3d_prepare_for_reset(ALLEGRO_DISPLAY_D3D *disp)
1002 {
1003 ALLEGRO_DISPLAY *al_display = (ALLEGRO_DISPLAY *)disp;
1004
1005 if (d3d_release_callback) {
1006 (*d3d_release_callback)(al_display);
1007 }
1008
1009 d3d_call_callbacks(&al_display->display_invalidated_callbacks, al_display);
1010
1011 _al_d3d_release_default_pool_textures((ALLEGRO_DISPLAY *)disp);
1012 while (disp->render_target && disp->render_target->Release() != 0) {
1013 ALLEGRO_WARN("_al_d3d_prepare_for_reset: (bb) ref count not 0\n");
1014 }
1015 disp->render_target = NULL;
1016 get_extra(al_get_backbuffer(al_display))->render_target = NULL;
1017 }
1018
1019 static bool _al_d3d_reset_device(ALLEGRO_DISPLAY_D3D *d3d_display)
1020 {
1021 ALLEGRO_DISPLAY_WIN *win_display = &d3d_display->win_display;
1022 ALLEGRO_DISPLAY *al_display = &win_display->display;
1023
1024 al_lock_mutex(_al_d3d_lost_device_mutex);
1025
1026 _al_d3d_prepare_for_reset(d3d_display);
1027
1028 if (al_display->flags & ALLEGRO_FULLSCREEN) {
1029 HRESULT hr;
1030
1031 ZeroMemory(&d3d_pp, sizeof(d3d_pp));
1032 d3d_pp.BackBufferFormat = (D3DFORMAT)_al_pixel_format_to_d3d(_al_deduce_color_format(&al_display->extra_settings));
1033 d3d_pp.BackBufferWidth = al_display->w;
1034 d3d_pp.BackBufferHeight = al_display->h;
1035 d3d_pp.BackBufferCount = 1;
1036 d3d_pp.Windowed = 0;
1037 d3d_pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
1038 d3d_pp.hDeviceWindow = win_display->window;
1039 if (d3d_display->vsync) {
1040 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
1041 }
1042 else {
1043 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
1044 }
1045
1046 if (d3d_display->depth_stencil_format) {
1047 d3d_pp.EnableAutoDepthStencil = true;
1048 d3d_pp.AutoDepthStencilFormat = d3d_display->depth_stencil_format;
1049 }
1050 if (d3d_display->samples) {
1051 d3d_pp.MultiSampleType = D3DMULTISAMPLE_NONMASKABLE;
1052 d3d_pp.MultiSampleQuality = d3d_display->samples;
1053 }
1054 else
1055 d3d_pp.Flags |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
1056
1057 if (d3d_display->single_buffer) {
1058 d3d_pp.SwapEffect = D3DSWAPEFFECT_COPY;
1059 }
1060 else {
1061 d3d_pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
1062 }
1063 if (al_display->refresh_rate) {
1064 d3d_pp.FullScreen_RefreshRateInHz =
1065 al_display->refresh_rate;
1066 }
1067 else {
1068 d3d_pp.FullScreen_RefreshRateInHz = d3d_get_default_refresh_rate(win_display->adapter);
1069 }
1070 #ifdef ALLEGRO_CFG_D3D9EX
1071 if (is_vista) {
1072 D3DDISPLAYMODEEX mode;
1073 IDirect3DDevice9Ex *dev = (IDirect3DDevice9Ex *)d3d_display->device;
1074 mode.Size = sizeof(D3DDISPLAYMODEEX);
1075 mode.Width = d3d_pp.BackBufferWidth;
1076 mode.Height = d3d_pp.BackBufferHeight;
1077 mode.RefreshRate = d3d_pp.FullScreen_RefreshRateInHz;
1078 mode.Format = d3d_pp.BackBufferFormat;
1079 mode.ScanLineOrdering = D3DSCANLINEORDERING_PROGRESSIVE;
1080 hr = dev->ResetEx(&d3d_pp, &mode);
1081 }
1082 else
1083 #endif
1084 {
1085 hr = d3d_display->device->Reset(&d3d_pp);
1086 }
1087 if (hr != D3D_OK) {
1088 switch (hr) {
1089 case D3DERR_INVALIDCALL:
1090 ALLEGRO_ERROR("D3DERR_INVALIDCALL in reset.\n");
1091 break;
1092 case D3DERR_NOTAVAILABLE:
1093 ALLEGRO_ERROR("D3DERR_NOTAVAILABLE in reset.\n");
1094 break;
1095 case D3DERR_OUTOFVIDEOMEMORY:
1096 ALLEGRO_ERROR("D3DERR_OUTOFVIDEOMEMORY in reset.\n");
1097 break;
1098 case D3DERR_DEVICELOST:
1099 ALLEGRO_ERROR("D3DERR_DEVICELOST in reset.\n");
1100 d3d_display->device_lost = true;
1101 break;
1102 default:
1103 ALLEGRO_ERROR("Direct3D Device reset failed (unknown reason).\n");
1104 break;
1105 }
1106 al_unlock_mutex(_al_d3d_lost_device_mutex);
1107 return 0;
1108 }
1109 }
1110 else {
1111 ZeroMemory(&d3d_pp, sizeof(d3d_pp));
1112 d3d_pp.BackBufferFormat = (D3DFORMAT)_al_pixel_format_to_d3d(_al_deduce_color_format(&al_display->extra_settings));
1113 d3d_pp.BackBufferWidth = al_display->w;
1114 d3d_pp.BackBufferHeight = al_display->h;
1115 d3d_pp.BackBufferCount = 1;
1116 d3d_pp.Windowed = 1;
1117 d3d_pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
1118 d3d_pp.hDeviceWindow = win_display->window;
1119 if (d3d_display->vsync) {
1120 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
1121 }
1122 else {
1123 d3d_pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
1124 }
1125
1126 if (d3d_display->depth_stencil_format) {
1127 d3d_pp.EnableAutoDepthStencil = true;
1128 d3d_pp.AutoDepthStencilFormat = d3d_display->depth_stencil_format;
1129 }
1130 if (d3d_display->samples) {
1131 d3d_pp.MultiSampleType = D3DMULTISAMPLE_NONMASKABLE;
1132 d3d_pp.MultiSampleQuality = d3d_display->samples;
1133 }
1134 else
1135 d3d_pp.Flags |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
1136
1137 if (d3d_display->single_buffer) {
1138 d3d_pp.SwapEffect = D3DSWAPEFFECT_COPY;
1139 }
1140 else {
1141 d3d_pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
1142 }
1143
1144 /* Must be 0 for windowed modes */
1145 d3d_pp.FullScreen_RefreshRateInHz = 0;
1146
1147 HRESULT hr = d3d_display->device->Reset(&d3d_pp);
1148 if (hr != D3D_OK) {
1149 switch (hr) {
1150 case D3DERR_INVALIDCALL:
1151 ALLEGRO_ERROR("D3DERR_INVALIDCALL in reset.\n");
1152 break;
1153 case D3DERR_NOTAVAILABLE:
1154 ALLEGRO_ERROR("D3DERR_NOTAVAILABLE in reset.\n");
1155 break;
1156 case D3DERR_OUTOFVIDEOMEMORY:
1157 ALLEGRO_ERROR("D3DERR_OUTOFVIDEOMEMORY in reset.\n");
1158 break;
1159 case D3DERR_DEVICELOST:
1160 ALLEGRO_ERROR("D3DERR_DEVICELOST in reset.\n");
1161 d3d_display->device_lost = true;
1162 break;
1163 default:
1164 ALLEGRO_ERROR("Direct3D Device reset failed (unknown reason).\n");
1165 break;
1166 }
1167 al_unlock_mutex(_al_d3d_lost_device_mutex);
1168 return 0;
1169 }
1170 }
1171
1172 d3d_display->device->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &d3d_display->render_target);
1173
1174 _al_d3d_refresh_texture_memory(al_display);
1175
1176 d3d_display->device->BeginScene();
1177
1178 d3d_reset_state(d3d_display);
1179
1180 /* Restore the target bitmap. */
1181 if (d3d_display->target_bitmap) {
1182 ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY*)d3d_display;
1183 d3d_set_target_bitmap(display, d3d_display->target_bitmap);
1184 d3d_update_transformation(display, d3d_display->target_bitmap);
1185 }
1186
1187 al_unlock_mutex(_al_d3d_lost_device_mutex);
1188
1189 return 1;
1190 }
1191
1192 static int d3d_choose_display_format(int fake)
1193 {
1194 /* Pick an appropriate format if the user is vague */
1195 switch (fake) {
1196 case ALLEGRO_PIXEL_FORMAT_ANY:
1197 case ALLEGRO_PIXEL_FORMAT_ANY_NO_ALPHA:
1198 case ALLEGRO_PIXEL_FORMAT_ANY_32_NO_ALPHA:
1199 fake = ALLEGRO_PIXEL_FORMAT_XRGB_8888;
1200 break;
1201 case ALLEGRO_PIXEL_FORMAT_ANY_16_NO_ALPHA:
1202 fake = ALLEGRO_PIXEL_FORMAT_RGB_565;
1203 break;
1204 default:
1205 break;
1206 }
1207
1208 return fake;
1209 }
1210
1211 static BOOL IsTextureFormatOk(D3DFORMAT TextureFormat, D3DFORMAT AdapterFormat)
1212 {
1213 HRESULT hr = _al_d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT,
1214 D3DDEVTYPE_HAL,
1215 AdapterFormat,
1216 0,
1217 D3DRTYPE_TEXTURE,
1218 TextureFormat);
1219
1220 if (hr != D3D_OK) {
1221 hr = _al_d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT,
1222 D3DDEVTYPE_REF,
1223 AdapterFormat,
1224 0,
1225 D3DRTYPE_TEXTURE,
1226 TextureFormat);
1227 }
1228
1229 return SUCCEEDED(hr);
1230 }
1231
1232 /* Same as above, but using Allegro's formats */
1233 static bool is_texture_format_ok(ALLEGRO_DISPLAY *display, int texture_format)
1234 {
1235 ALLEGRO_DISPLAY_D3D *d3d_display = (ALLEGRO_DISPLAY_D3D*)display;
1236 return IsTextureFormatOk((D3DFORMAT)_al_pixel_format_to_d3d(texture_format),
1237 (D3DFORMAT)_al_pixel_format_to_d3d(d3d_display->format));
1238 }
1239
1240 static int real_choose_bitmap_format(ALLEGRO_DISPLAY_D3D *d3d_display,
1241 int bits, bool alpha)
1242 {
1243 int i;
1244
1245 for (i = 0; allegro_formats[i] >= 0; i++) {
1246 int aformat = allegro_formats[i];
1247 D3DFORMAT dformat;
1248 D3DFORMAT adapter_format;
1249 int adapter_format_allegro;
1250 if (!_al_pixel_format_is_real(aformat)) {
1251 ALLEGRO_DEBUG("Fake format\n");
1252 continue;
1253 }
1254 if (bits && al_get_pixel_format_bits(aformat) != bits) {
1255 ALLEGRO_DEBUG("#Bits don't match\n");
1256 continue;
1257 }
1258 if (alpha && !_al_pixel_format_has_alpha(aformat)) {
1259 ALLEGRO_DEBUG("Alpha doesn't match\n");
1260 continue;
1261 }
1262 dformat = (D3DFORMAT)d3d_formats[i];
1263 adapter_format_allegro = d3d_display->format;
1264 if (!_al_pixel_format_is_real(adapter_format_allegro))
1265 adapter_format_allegro = d3d_choose_display_format(adapter_format_allegro);
1266 ALLEGRO_DEBUG("Adapter format is %d\n", adapter_format_allegro);
1267 adapter_format = (D3DFORMAT)_al_pixel_format_to_d3d(adapter_format_allegro);
1268 if (IsTextureFormatOk(dformat, adapter_format)) {
1269 ALLEGRO_DEBUG("Found a format\n");
1270 return aformat;
1271 }
1272 ALLEGRO_DEBUG("Texture format not OK\n");
1273 }
1274
1275 ALLEGRO_WARN("Failed to find format\n");
1276
1277 return -1;
1278 }
1279
1280 static int d3d_choose_bitmap_format(ALLEGRO_DISPLAY_D3D *d3d_display, int fake)
1281 {
1282 switch (fake) {
1283 case ALLEGRO_PIXEL_FORMAT_ANY_NO_ALPHA:
1284 fake = real_choose_bitmap_format(d3d_display, 0, false);
1285 break;
1286 case ALLEGRO_PIXEL_FORMAT_ANY:
1287 case ALLEGRO_PIXEL_FORMAT_ANY_WITH_ALPHA:
1288 fake = real_choose_bitmap_format(d3d_display, 0, true);
1289 break;
1290 case ALLEGRO_PIXEL_FORMAT_ANY_32_NO_ALPHA:
1291 fake = real_choose_bitmap_format(d3d_display, 32, false);
1292 break;
1293 case ALLEGRO_PIXEL_FORMAT_ANY_32_WITH_ALPHA:
1294 fake = real_choose_bitmap_format(d3d_display, 32, true);
1295 break;
1296 case ALLEGRO_PIXEL_FORMAT_ANY_24_NO_ALPHA:
1297 fake = real_choose_bitmap_format(d3d_display, 24, false);
1298 break;
1299 case ALLEGRO_PIXEL_FORMAT_ANY_16_NO_ALPHA:
1300 fake = real_choose_bitmap_format(d3d_display, 16, false);
1301 break;
1302 case ALLEGRO_PIXEL_FORMAT_ANY_16_WITH_ALPHA:
1303 fake = real_choose_bitmap_format(d3d_display, 16, true);
1304 break;
1305 case ALLEGRO_PIXEL_FORMAT_ANY_15_NO_ALPHA:
1306 fake = real_choose_bitmap_format(d3d_display, 15, false);
1307 break;
1308 default:
1309 fake = -1;
1310 }
1311
1312 return fake;
1313 }
1314
1315 struct CREATE_WINDOW_INFO {
1316 ALLEGRO_DISPLAY *display;
1317 DISPLAY_DEVICE dd;
1318 ALLEGRO_MONITOR_INFO mi;
1319 int w;
1320 int h;
1321 int refresh_rate;
1322 int flags;
1323 bool inited;
1324 bool quit;
1325 };
1326
1327 static void d3d_create_window_proc(CREATE_WINDOW_INFO *info)
1328 {
1329 ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)info->display;
1330
1331 win_display->window = _al_win_create_window(
1332 info->display,
1333 info->w,
1334 info->h,
1335 info->flags
1336 );
1337 }
1338
1339 static void *d3d_create_faux_fullscreen_window_proc(void *arg)
1340 {
1341 CREATE_WINDOW_INFO *info = (CREATE_WINDOW_INFO *)arg;
1342 ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)info->display;
1343
1344 win_display->window =
1345 _al_win_create_faux_fullscreen_window(
1346 info->dd.DeviceName,
1347 info->display,
1348 info->mi.x1,
1349 info->mi.y1,
1350 info->w,
1351 info->h,
1352 info->refresh_rate,
1353 info->flags
1354 );
1355
1356 return NULL;
1357 }
1358
1359 /*
1360 * Display must be created in same thread that resets it
1361 */
1362 static void *d3d_display_thread_proc(void *arg)
1363 {
1364 ALLEGRO_DISPLAY_D3D *d3d_display;
1365 ALLEGRO_DISPLAY_WIN *win_display;
1366 ALLEGRO_DISPLAY *al_display;
1367 D3D_DISPLAY_PARAMETERS *params = (D3D_DISPLAY_PARAMETERS *)arg;
1368 int new_format;
1369 bool convert_to_faux;
1370 CREATE_WINDOW_INFO *info = (CREATE_WINDOW_INFO *)al_calloc(1, sizeof(*info));
1371 HRESULT hr;
1372 bool lost_event_generated = false;
1373 D3DCAPS9 caps;
1374 MSG msg;
1375
1376 d3d_display = params->display;
1377 win_display = &d3d_display->win_display;
1378 al_display = &win_display->display;
1379
1380 if (al_display->flags & ALLEGRO_FULLSCREEN) {
1381 convert_to_faux = true;
1382 }
1383 else {
1384 convert_to_faux = false;
1385 }
1386
1387 /* So that we can call the functions using TLS from this thread. */
1388 al_set_new_display_flags(al_display->flags);
1389 al_set_new_window_position(params->window_x, params->window_y);
1390 al_set_new_window_title(params->window_title);
1391
1392 new_format = _al_deduce_color_format(&al_display->extra_settings);
1393
1394 /* This should never happen, I think */
1395 if (!_al_pixel_format_is_real(_al_deduce_color_format(&al_display->extra_settings))) {
1396 int f = d3d_choose_display_format(_al_deduce_color_format(&al_display->extra_settings));
1397 if (f < 0) {
1398 d3d_destroy_display(al_display);
1399 params->init_failed = true;
1400 SetEvent(params->AckEvent);
1401 return NULL;
1402 }
1403 new_format = f;
1404 _al_set_color_components(new_format, &al_display->extra_settings, ALLEGRO_REQUIRE);
1405 }
1406
1407 ALLEGRO_INFO("Chose a display format: %d\n", new_format);
1408 d3d_display->format = new_format;
1409
1410 if (d3d_display->faux_fullscreen) {
1411 DEVMODE dm;
1412 bool found = true;
1413 int refresh_rate;
1414
1415 num_faux_fullscreen_windows++;
1416
1417 d3d_make_faux_fullscreen_stage_one(d3d_display);
1418
1419 al_get_monitor_info(win_display->adapter, &info->mi);
1420 /* Yes this is an "infinite" loop (suggested by MS on msdn) */
1421 for (int i = 0; ; i++) {
1422 info->dd.cb = sizeof(info->dd);
1423 if (!EnumDisplayDevices(NULL, i, &info->dd, 0)) {
1424 found = false;
1425 break;
1426 }
1427 if (!EnumDisplaySettings(info->dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm)) {
1428 continue;
1429 }
1430 if (info->mi.x1 == dm.dmPosition.x && info->mi.y1 == dm.dmPosition.y) {
1431 break;
1432 }
1433
1434 }
1435 if (!found) {
1436 ALLEGRO_ERROR("d3d_display_thread_proc: Error setting faux fullscreen mode.\n");
1437 num_faux_fullscreen_windows--;
1438 d3d_destroy_display(al_display);
1439 params->init_failed = true;
1440 SetEvent(params->AckEvent);
1441 return NULL;
1442 }
1443 if (al_display->refresh_rate) {
1444 refresh_rate = al_display->refresh_rate;
1445 }
1446 else {
1447 refresh_rate = d3d_get_default_refresh_rate(win_display->adapter);
1448 }
1449 d3d_display->device_name = (TCHAR *)al_malloc(sizeof(TCHAR)*32);
1450 strcpy((char*)d3d_display->device_name, (char*)info->dd.DeviceName);
1451 ALLEGRO_DEBUG("going to call _al_win_create_faux_fullscreen_window\n");
1452
1453 info->display = al_display;
1454 info->w = al_display->w;
1455 info->h = al_display->h;
1456 info->refresh_rate = refresh_rate;
1457 info->flags = al_display->flags;
1458
1459 d3d_create_faux_fullscreen_window_proc(info);
1460
1461 if (!win_display->window) {
1462 ALLEGRO_DEBUG("Failed to create window (faux)fullscreen.\n");
1463 d3d_destroy_display(al_display);
1464 params->init_failed = true;
1465 SetEvent(params->AckEvent);
1466 return NULL;
1467 }
1468
1469 ALLEGRO_DEBUG("Called _al_win_create_faux_fullscreen_window.\n");
1470
1471 d3d_make_faux_fullscreen_stage_two(d3d_display);
1472
1473 convert_to_faux = false;
1474 }
1475 else {
1476 ALLEGRO_INFO("Normal window.\n");
1477
1478 info->display = al_display;
1479 info->w = al_display->w;
1480 info->h = al_display->h;
1481 info->flags = al_display->flags;
1482
1483 d3d_create_window_proc(info);
1484 }
1485
1486 if (!win_display->window) {
1487 ALLEGRO_DEBUG("Failed to create regular window.\n");
1488 d3d_destroy_display(al_display);
1489 params->init_failed = true;
1490 SetEvent(params->AckEvent);
1491 return NULL;
1492 }
1493
1494 if (!(al_display->flags & ALLEGRO_FULLSCREEN) || d3d_display->faux_fullscreen) {
1495 if (!d3d_create_device(d3d_display, _al_deduce_color_format(&al_display->extra_settings),
1496 al_display->refresh_rate, al_display->flags, convert_to_faux)) {
1497 d3d_destroy_display(al_display);
1498 params->init_failed = true;
1499 SetEvent(params->AckEvent);
1500 return NULL;
1501 }
1502 }
1503 else {
1504 ALLEGRO_DEBUG("Creating real fullscreen device\n");
1505 if (!d3d_create_fullscreen_device(d3d_display, _al_deduce_color_format(&al_display->extra_settings),
1506 al_display->refresh_rate, al_display->flags)) {
1507 d3d_destroy_display(al_display);
1508 params->init_failed = true;
1509 SetEvent(params->AckEvent);
1510 return NULL;
1511 }
1512 ALLEGRO_INFO("Real fullscreen device created\n");
1513 }
1514
1515 al_display->backbuffer_format = _al_deduce_color_format(&al_display->extra_settings);
1516
1517
1518 d3d_display->device->GetDeviceCaps(&caps);
1519 d3d_can_wait_for_vsync = ((caps.Caps & D3DCAPS_READ_SCANLINE) != 0);
1520
1521 params->init_failed = false;
1522 win_display->thread_ended = false;
1523 win_display->end_thread = false;
1524 SetEvent(params->AckEvent);
1525
1526 while (!win_display->end_thread) {
1527 al_rest(0.001);
1528
1529 if (PeekMessage(&msg, NULL, 0, 0, FALSE)) {
1530 if (GetMessage(&msg, NULL, 0, 0) != 0)
1531 DispatchMessage(&msg);
1532 else
1533 break; /* WM_QUIT received or error (GetMessage returned -1) */
1534 }
1535
1536 if (!d3d_display->device) {
1537 continue;
1538 }
1539
1540 if (d3d_display->device_lost) {
1541 hr = d3d_display->device->TestCooperativeLevel();
1542
1543 if (hr == D3D_OK) {
1544 d3d_display->device_lost = false;
1545 }
1546 else if (hr == D3DERR_DEVICELOST) {
1547 /* device remains lost */
1548 if (!lost_event_generated) {
1549 ALLEGRO_DEBUG("D3DERR_DEVICELOST: d3d_display=%p\n", d3d_display);
1550 lost_event_generated = true;
1551 if (d3d_display->suppress_lost_events) {
1552 ALLEGRO_DEBUG("DISPLAY_LOST event suppressed\n");
1553 }
1554 else {
1555 _al_event_source_lock(&al_display->es);
1556 if (_al_event_source_needs_to_generate_event(&al_display->es)) {
1557 ALLEGRO_EVENT event;
1558 memset(&event, 0, sizeof(event));
1559 event.display.type = ALLEGRO_EVENT_DISPLAY_LOST;
1560 event.display.timestamp = al_get_time();
1561 _al_event_source_emit_event(&al_display->es, &event);
1562 }
1563 _al_event_source_unlock(&al_display->es);
1564 al_rest(0.5); // give user time to respond
1565 }
1566 }
1567 }
1568 else if (hr == D3DERR_DEVICENOTRESET) {
1569 if (_al_d3d_reset_device(d3d_display)) {
1570 d3d_display->device_lost = false;
1571 d3d_reset_state(d3d_display);
1572 _al_event_source_lock(&al_display->es);
1573 if (_al_event_source_needs_to_generate_event(&al_display->es)) {
1574 ALLEGRO_EVENT event;
1575 memset(&event, 0, sizeof(event));
1576 event.display.type = ALLEGRO_EVENT_DISPLAY_FOUND;
1577 event.display.timestamp = al_get_time();
1578 _al_event_source_emit_event(&al_display->es, &event);
1579 }
1580 _al_event_source_unlock(&al_display->es);
1581 lost_event_generated = false;
1582 d3d_call_callbacks(&al_display->display_validated_callbacks, al_display);
1583 if (d3d_restore_callback) {
1584 (*d3d_restore_callback)(al_display);
1585 }
1586 }
1587 }
1588 }
1589 if (d3d_display->do_reset) {
1590 d3d_display->reset_success = _al_d3d_reset_device(d3d_display);
1591 if (d3d_restore_callback) {
1592 (*d3d_restore_callback)(al_display);
1593 }
1594 d3d_display->do_reset = false;
1595 d3d_display->reset_done = true;
1596 }
1597 }
1598
1599 d3d_destroy_device(d3d_display);
1600
1601 if (d3d_display->faux_fullscreen) {
1602 ChangeDisplaySettingsEx(d3d_display->device_name, NULL, NULL, 0, NULL);
1603 al_free(d3d_display->device_name);
1604 num_faux_fullscreen_windows--;
1605 }
1606
1607 win_display->thread_ended = true;
1608
1609 al_free(info);
1610
1611 ALLEGRO_INFO("d3d display thread exits\n");
1612
1613 return NULL;
1614 }
1615
1616
1617 static ALLEGRO_DISPLAY_D3D *d3d_create_display_helper(int w, int h)
1618 {
1619 ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver();
1620 ALLEGRO_DISPLAY_D3D *d3d_display = (ALLEGRO_DISPLAY_D3D *)al_malloc(sizeof(ALLEGRO_DISPLAY_D3D));
1621 ALLEGRO_DISPLAY_WIN *win_display = &d3d_display->win_display;
1622 ALLEGRO_DISPLAY *al_display = &win_display->display;
1623
1624 memset(d3d_display, 0, sizeof *d3d_display);
1625
1626 win_display->adapter = _al_win_determine_adapter();
1627
1628 /* w/h may be reset below if ALLEGRO_FULLSCREEN_WINDOW is set */
1629 al_display->w = w;
1630 al_display->h = h;
1631 al_display->refresh_rate = al_get_new_display_refresh_rate();
1632 al_display->flags = al_get_new_display_flags();
1633 al_display->vt = vt;
1634 ASSERT(al_display->vt);
1635
1636 #ifdef ALLEGRO_CFG_D3D9EX
1637 if (!is_vista)
1638 #endif
1639 {
1640 if (al_display->flags & ALLEGRO_FULLSCREEN) {
1641 if (already_fullscreen || system->system.displays._size != 0) {
1642 d3d_display->faux_fullscreen = true;
1643 }
1644 else {
1645 already_fullscreen = true;
1646 d3d_display->faux_fullscreen = false;
1647 }
1648 }
1649 }
1650 #ifdef ALLEGRO_CFG_D3D9EX
1651 else {
1652 d3d_display->faux_fullscreen = false;
1653 }
1654 #endif
1655
1656 if (!(al_display->flags & ALLEGRO_FULLSCREEN)) {
1657 if (al_display->flags & ALLEGRO_FULLSCREEN_WINDOW) {
1658 ALLEGRO_MONITOR_INFO mi;
1659 al_get_monitor_info(win_display->adapter, &mi);
1660 al_display->w = mi.x2 - mi.x1;
1661 al_display->h = mi.y2 - mi.y1;
1662 d3d_display->faux_fullscreen = true;
1663 }
1664 else {
1665 d3d_display->faux_fullscreen = false;
1666 }
1667 win_display->toggle_w = w;
1668 win_display->toggle_h = h;
1669 }
1670
1671 return d3d_display;
1672 }
1673
1674 /* This function may return the original d3d_display argument,
1675 * or a new one, or NULL on error.
1676 */
1677 static ALLEGRO_DISPLAY_D3D *d3d_create_display_internals(
1678 ALLEGRO_DISPLAY_D3D *d3d_display, bool free_on_error)
1679 {
1680 D3D_DISPLAY_PARAMETERS params;
1681 ALLEGRO_DISPLAY_WIN *win_display = &d3d_display->win_display;
1682 ALLEGRO_DISPLAY *al_display = &win_display->display;
1683 ALLEGRO_EXTRA_DISPLAY_SETTINGS *ref = _al_get_new_display_settings();
1684 int num_modes;
1685 int i;
1686 int window_x, window_y;
1687 /* save width and height in case new fullscreen-mode
1688 * fails inside d3d_display_thread_proc and destroys al_display */
1689 int pre_destroy_w = al_display->w;
1690 int pre_destroy_h = al_display->h;
1691
1692 params.display = d3d_display;
1693
1694 /* The window is created in a separate thread so we need to pass this
1695 * TLS on
1696 */
1697 al_get_new_window_position(&window_x, &window_y);
1698 params.window_x = window_x;
1699 params.window_y = window_y;
1700 params.window_title = al_get_new_window_title();
1701
1702 _al_d3d_generate_display_format_list();
1703
1704 _al_d3d_score_display_settings(ref);
1705
1706 /* Checking each mode is slow, so do a resolution check first */
1707 if (al_display->flags & ALLEGRO_FULLSCREEN) {
1708 num_modes = al_get_num_display_modes();
1709 while (num_modes >= 0) {
1710 ALLEGRO_DISPLAY_MODE mode;
1711 al_get_display_mode(num_modes, &mode);
1712 if (mode.width == al_display->w && mode.height == al_display->h) {
1713 break;
1714 }
1715 num_modes--;
1716 }
1717 if (num_modes < 0) {
1718 // Failing resolution test is like failing to create a window
1719 // This helps determining if the window message thread needs
1720 // to be destroyed.
1721 win_display->window = NULL;
1722 if (free_on_error) {
1723 al_free(d3d_display);
1724 }
1725 return NULL;
1726 }
1727 }
1728
1729 ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds = NULL;
1730 for (i = 0; (eds = _al_d3d_get_display_settings(i)); i++) {
1731 ALLEGRO_DEBUG("Trying format %d.\n", eds->index);
1732
1733 d3d_display->depth_stencil_format = d3d_get_depth_stencil_format(eds);
1734 if (eds->settings[ALLEGRO_SAMPLES] > 0)
1735 d3d_display->samples = eds->settings[ALLEGRO_SAMPLES] - 1;
1736 else
1737 d3d_display->samples = 0;
1738 d3d_display->single_buffer = eds->settings[ALLEGRO_SINGLE_BUFFER] ? true : false;
1739 d3d_display->vsync = eds->settings[ALLEGRO_VSYNC] == 1;
1740
1741 memcpy(&al_display->extra_settings, eds, sizeof al_display->extra_settings);
1742
1743 params.init_failed = true;
1744 win_display->thread_ended = true;
1745 params.AckEvent = CreateEvent(NULL, false, false, NULL);
1746
1747 al_run_detached_thread(d3d_display_thread_proc, &params);
1748 /* Wait some _finite_ time (10 secs or so) for display thread to init, and
1749 * give up if something horrible happened to it, unless we're in debug mode
1750 * and we may have intentionally stopped the execution to analyze the code.
1751 */
1752 #ifdef DEBUGMODE
1753 WaitForSingleObject(params.AckEvent, INFINITE);
1754 #else
1755 WaitForSingleObject(params.AckEvent, 10*1000);
1756 #endif
1757 ALLEGRO_DEBUG("Resumed after wait.\n");
1758
1759 CloseHandle(params.AckEvent);
1760
1761 if (!params.init_failed) {
1762 break;
1763 }
1764
1765 ALLEGRO_INFO("Format %d failed.\n", i);
1766
1767 // Display has been destroyed in d3d_display_thread_proc, create empty template again
1768 d3d_display = d3d_create_display_helper(pre_destroy_w, pre_destroy_h);
1769 win_display = &d3d_display->win_display;
1770 al_display = &win_display->display;
1771 params.display = d3d_display;
1772
1773 ALLEGRO_DEBUG("d3d_display = %p\n", d3d_display);
1774 ALLEGRO_DEBUG("win_display = %p\n", win_display);
1775 ALLEGRO_DEBUG("al_display = %p\n", al_display);
1776 ASSERT(al_display->vt);
1777 }
1778
1779 // Re-sort the display format list for use later
1780 _al_d3d_resort_display_settings();
1781
1782 if (!eds) {
1783 ALLEGRO_WARN("All %d formats failed.\n", i);
1784 if (free_on_error) {
1785 al_free(d3d_display);
1786 }
1787 return NULL;
1788 }
1789
1790 ALLEGRO_INFO("Format %d succeeded.\n", eds->index);
1791
1792 d3d_reset_state(d3d_display);
1793
1794 d3d_display->backbuffer_bmp.extra = &d3d_display->backbuffer_bmp_extra;
1795 d3d_display->backbuffer_bmp_extra.is_backbuffer = true;
1796 d3d_display->backbuffer_bmp._display = al_display;
1797 d3d_display->backbuffer_bmp._format = _al_deduce_color_format(&al_display->extra_settings);
1798 d3d_display->backbuffer_bmp._memory_format = d3d_display->backbuffer_bmp._format;
1799 d3d_display->backbuffer_bmp_extra.system_format = d3d_display->backbuffer_bmp._format;
1800 d3d_display->backbuffer_bmp._flags = ALLEGRO_VIDEO_BITMAP;
1801 d3d_display->backbuffer_bmp.w = al_display->w;
1802 d3d_display->backbuffer_bmp.h = al_display->h;
1803 d3d_display->backbuffer_bmp_extra.texture_w = al_display->w;
1804 d3d_display->backbuffer_bmp_extra.texture_h = al_display->h;
1805 d3d_display->backbuffer_bmp.cl = 0;
1806 d3d_display->backbuffer_bmp.ct = 0;
1807 d3d_display->backbuffer_bmp.cr_excl = al_display->w;
1808 d3d_display->backbuffer_bmp.cb_excl = al_display->h;
1809 d3d_display->backbuffer_bmp.vt = (ALLEGRO_BITMAP_INTERFACE *)_al_bitmap_d3d_driver();
1810 d3d_display->backbuffer_bmp_extra.display = d3d_display;
1811 d3d_display->target_bitmap = NULL;
1812 al_identity_transform(&d3d_display->backbuffer_bmp.transform);
1813 al_identity_transform(&d3d_display->backbuffer_bmp.proj_transform);
1814 al_orthographic_transform(&d3d_display->backbuffer_bmp.proj_transform, 0, 0, -1.0, al_display->w, al_display->h, 1.0);
1815
1816 /* Alpha blending is the default */
1817 d3d_display->device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
1818 d3d_display->device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
1819 d3d_display->device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
1820
1821 if (!check_use_fixed_pipeline(d3d_display->device)) {
1822 HRESULT res;
1823
1824 res = d3d_display->device->CreateIndexBuffer(2 * sizeof(int), 0, D3DFMT_INDEX32, D3DPOOL_MANAGED, &d3d_display->loop_index_buffer, 0);
1825 if (res != D3D_OK) {
1826 ALLEGRO_WARN("CreateIndexBuffer failed: %ld.\n", res);
1827 if (free_on_error) {
1828 win_display->end_thread = true;
1829 while (!win_display->thread_ended)
1830 al_rest(0.001);
1831 d3d_destroy_display_internals(d3d_display);
1832 al_free(d3d_display);
1833 }
1834 return NULL;
1835 }
1836
1837 res = d3d_display->device->CreateVertexShader((const DWORD*)prim_shader_vs_bin, &d3d_display->primitives_shader);
1838
1839 if (res != D3D_OK) {
1840 ALLEGRO_WARN("Creating the primitives HLSL shader failed: %ld.\n", res);
1841 if (free_on_error) {
1842 win_display->end_thread = true;
1843 while (!win_display->thread_ended)
1844 al_rest(0.001);
1845 d3d_display->loop_index_buffer->Release();
1846 al_free(d3d_display);
1847 }
1848 return NULL;
1849 }
1850 }
1851
1852 ALLEGRO_DEBUG("Returning d3d_display: %p\n", d3d_display);
1853 return d3d_display;
1854 }
1855
1856 static ALLEGRO_DISPLAY *d3d_create_display_locked(int w, int h)
1857 {
1858 ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver();
1859 ALLEGRO_DISPLAY_D3D *d3d_display = d3d_create_display_helper(w, h);
1860 ALLEGRO_DISPLAY_WIN *win_display = &d3d_display->win_display;
1861 ALLEGRO_DISPLAY *al_display = &win_display->display;
1862 ALLEGRO_DISPLAY_D3D **add;
1863 D3DCAPS9 caps;
1864
1865 ALLEGRO_INFO("faux_fullscreen=%d\n", d3d_display->faux_fullscreen);
1866 ALLEGRO_DEBUG("al_display=%p\n", al_display);
1867 ALLEGRO_DEBUG("al_display->vt=%p\n", al_display->vt);
1868 ASSERT(al_display->vt);
1869
1870 d3d_display = d3d_create_display_internals(d3d_display, true);
1871 if (!d3d_display) {
1872 ALLEGRO_ERROR("d3d_create_display failed.\n");
1873 return NULL;
1874 }
1875 win_display = &d3d_display->win_display;
1876 al_display = &win_display->display;
1877 ALLEGRO_DEBUG("al_display=%p\n", al_display);
1878 ALLEGRO_DEBUG("al_display->vt=%p\n", al_display->vt);
1879 ASSERT(al_display->vt);
1880
1881 /* Add ourself to the list of displays. */
1882 add = (ALLEGRO_DISPLAY_D3D **)_al_vector_alloc_back(&system->system.displays);
1883 *add = d3d_display;
1884
1885 /* Each display is an event source. */
1886 _al_event_source_init(&al_display->es);
1887 d3d_display->es_inited = true;
1888
1889 #if 0
1890 /* Setup the mouse */
1891 if (al_display->flags & ALLEGRO_FULLSCREEN && al_is_mouse_installed()) {
1892 RAWINPUTDEVICE rid[1];
1893 rid[0].usUsagePage = 0x01;
1894 rid[0].usUsage = 0x02;
1895 rid[0].dwFlags = RIDEV_NOLEGACY;
1896 rid[0].hwndTarget = 0;
1897 if (RegisterRawInputDevices(rid, 1, sizeof(rid[0])) == FALSE) {
1898 ALLEGRO_WARN("Failed to init mouse.\n");
1899 }
1900 }
1901 #endif
1902
1903 win_display->mouse_selected_hcursor = 0;
1904 win_display->mouse_cursor_shown = false;
1905 win_display->hide_mouse_on_move = false;
1906
1907 SetForegroundWindow(win_display->window);
1908 _al_win_grab_input(win_display);
1909
1910 _al_win_show_mouse_cursor(al_display);
1911
1912 if (_al_d3d->GetDeviceCaps(win_display->adapter, D3DDEVTYPE_HAL, &caps) != D3D_OK
1913 && _al_d3d->GetDeviceCaps(win_display->adapter, D3DDEVTYPE_REF, &caps) != D3D_OK) {
1914 d3d_display->supports_separate_alpha_blend = false;
1915 }
1916 else {
1917 d3d_display->supports_separate_alpha_blend =
1918 ((caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) != 0);
1919 }
1920
1921 ASSERT(al_display->vt);
1922 return al_display;
1923 }
1924
1925 static ALLEGRO_DISPLAY *d3d_create_display(int w, int h)
1926 {
1927 ALLEGRO_DISPLAY *display;
1928 ALLEGRO_DISPLAY_WIN *win_display;
1929 int *s;
1930
1931 al_lock_mutex(present_mutex);
1932 display = d3d_create_display_locked(w, h);
1933 win_display = (ALLEGRO_DISPLAY_WIN *)display;
1934 al_unlock_mutex(present_mutex);
1935
1936 if (!display)
1937 return NULL;
1938
1939 ASSERT(display->vt);
1940
1941 s = display->extra_settings.settings;
1942 s[ALLEGRO_MAX_BITMAP_SIZE] = d3d_get_max_texture_size(win_display->adapter);
1943 s[ALLEGRO_SUPPORT_SEPARATE_ALPHA] = _al_d3d_supports_separate_alpha_blend(display);
1944 s[ALLEGRO_SUPPORT_NPOT_BITMAP] = al_have_d3d_non_pow2_texture_support();
1945 s[ALLEGRO_CAN_DRAW_INTO_BITMAP] = render_to_texture_supported;
1946
1947 _al_win_post_create_window(display);
1948
1949 return display;
1950 }
1951
1952 static bool d3d_set_current_display(ALLEGRO_DISPLAY *d)
1953 {
1954 ALLEGRO_DISPLAY_D3D *d3d_display = (ALLEGRO_DISPLAY_D3D *)d;
1955
1956 if (d3d_display->do_reset)
1957 return false;
1958
1959 _al_d3d_update_render_state(d);
1960
1961 return true;
1962 }
1963
1964
1965 static int d3d_al_blender_to_d3d(int al_mode)
1966 {
1967 const int d3d_modes[ALLEGRO_NUM_BLEND_MODES] = {
1968 D3DBLEND_ZERO,
1969 D3DBLEND_ONE,
1970 D3DBLEND_SRCALPHA,
1971 D3DBLEND_INVSRCALPHA,
1972 D3DBLEND_SRCCOLOR,
1973 D3DBLEND_DESTCOLOR,
1974 D3DBLEND_INVSRCCOLOR,
1975 D3DBLEND_INVDESTCOLOR,
1976 D3DBLEND_BLENDFACTOR,
1977 D3DBLEND_INVBLENDFACTOR
1978 };
1979
1980 return d3d_modes[al_mode];
1981 }
1982
1983 void _al_d3d_set_blender(ALLEGRO_DISPLAY_D3D *d3d_display)
1984 {
1985 bool blender_changed;
1986 int op, src, dst, alpha_op, alpha_src, alpha_dst;
1987 ALLEGRO_COLOR color;
1988 unsigned char r, g, b, a;
1989 DWORD allegro_to_d3d_blendop[ALLEGRO_NUM_BLEND_OPERATIONS] = {
1990 D3DBLENDOP_ADD,
1991 D3DBLENDOP_SUBTRACT,
1992 D3DBLENDOP_REVSUBTRACT
1993 };
1994
1995 blender_changed = false;
1996
1997 al_get_separate_bitmap_blender(&op, &src, &dst,
1998 &alpha_op, &alpha_src, &alpha_dst);
1999 color = al_get_bitmap_blend_color();
2000 al_unmap_rgba(color, &r, &g, &b, &a);
2001
2002 if (d3d_display->blender_state_op != op) {
2003 /* These may not be supported but they will always fall back to ADD
2004 * in that case.
2005 */
2006 d3d_display->device->SetRenderState(D3DRS_BLENDOP, allegro_to_d3d_blendop[op]);
2007 d3d_display->blender_state_op = op;
2008 blender_changed = true;
2009 }
2010
2011 if (d3d_display->blender_state_alpha_op != alpha_op) {
2012 /* These may not be supported but they will always fall back to ADD
2013 * in that case.
2014 */
2015 d3d_display->device->SetRenderState(D3DRS_BLENDOPALPHA, allegro_to_d3d_blendop[alpha_op]);
2016 d3d_display->blender_state_alpha_op = alpha_op;
2017 blender_changed = true;
2018 }
2019
2020 if (d3d_display->blender_state_src != src) {
2021 if (d3d_display->device->SetRenderState(D3DRS_SRCBLEND, d3d_al_blender_to_d3d(src)) != D3D_OK)
2022 ALLEGRO_ERROR("Failed to set source blender\n");
2023 d3d_display->blender_state_src = src;
2024 blender_changed = true;
2025 }
2026
2027 if (d3d_display->blender_state_dst != dst) {
2028 if (d3d_display->device->SetRenderState(D3DRS_DESTBLEND, d3d_al_blender_to_d3d(dst)) != D3D_OK)
2029 ALLEGRO_ERROR("Failed to set dest blender\n");
2030 d3d_display->blender_state_dst = dst;
2031 blender_changed = true;
2032 }
2033
2034 if (d3d_display->blender_state_alpha_src != alpha_src) {
2035 if (d3d_display->device->SetRenderState(D3DRS_SRCBLENDALPHA, d3d_al_blender_to_d3d(alpha_src)) != D3D_OK)
2036 ALLEGRO_ERROR("Failed to set source alpha blender\n");
2037 d3d_display->blender_state_alpha_src = alpha_src;
2038 blender_changed = true;
2039 }
2040
2041 if (d3d_display->blender_state_alpha_dst != alpha_dst) {
2042 if (d3d_display->device->SetRenderState(D3DRS_DESTBLENDALPHA, d3d_al_blender_to_d3d(alpha_dst)) != D3D_OK)
2043 ALLEGRO_ERROR("Failed to set dest alpha blender\n");
2044 d3d_display->blender_state_alpha_dst = alpha_dst;
2045 blender_changed = true;
2046 }
2047
2048 if (blender_changed) {
2049 bool enable_separate_blender = (op != alpha_op) || (src != alpha_src) || (dst != alpha_dst);
2050 d3d_display->device->SetRenderState(D3DRS_BLENDFACTOR, D3DCOLOR_RGBA(r, g, b, a));
2051 if (enable_separate_blender) {
2052 if (d3d_display->device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, true) != D3D_OK)
2053 ALLEGRO_ERROR("D3DRS_SEPARATEALPHABLENDENABLE failed\n");
2054 }
2055
2056 /* thedmd: Why is this function called anyway? */
2057 d3d_display->device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
2058 }
2059 }
2060
2061 static void d3d_clear(ALLEGRO_DISPLAY *al_display, ALLEGRO_COLOR *color)
2062 {
2063 ALLEGRO_BITMAP *target = al_get_target_bitmap();
2064 ALLEGRO_DISPLAY_D3D* d3d_display = (ALLEGRO_DISPLAY_D3D*)al_display;
2065
2066 if (target->parent) target = target->parent;
2067
2068 if (d3d_display->device_lost)
2069 return;
2070 if (d3d_display->device->Clear(0, NULL, D3DCLEAR_TARGET,
2071 D3DCOLOR_ARGB((int)(color->a*255), (int)(color->r*255),
2072 (int)(color->g*255), (int)(color->b*255)), 0, 0) != D3D_OK) {
2073 ALLEGRO_ERROR("Clear failed\n");
2074 }
2075 }
2076
2077 static void d3d_clear_depth_buffer(ALLEGRO_DISPLAY *al_display, float z)
2078 {
2079 ALLEGRO_BITMAP *target = al_get_target_bitmap();
2080 ALLEGRO_DISPLAY_D3D* d3d_display = (ALLEGRO_DISPLAY_D3D*)al_display;
2081
2082 if (target->parent) target = target->parent;
2083
2084 if (d3d_display->device_lost)
2085 return;
2086 if (d3d_display->device->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0, z, 0)
2087 != D3D_OK) {
2088 ALLEGRO_ERROR("Clear zbuffer failed\n");
2089 }
2090 }
2091
2092
2093
2094 // FIXME: does this need a programmable pipeline path?
2095 static void d3d_draw_pixel(ALLEGRO_DISPLAY *disp, float x, float y, ALLEGRO_COLOR *color)
2096 {
2097 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)disp;
2098
2099 _al_d3d_set_blender(d3d_disp);
2100
2101 #ifdef ALLEGRO_CFG_SHADER_HLSL
2102 if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
2103 UINT required_passes;
2104 ALLEGRO_VERTEX vertices[1];
2105 vertices[0].x = x;
2106 vertices[0].y = y;
2107 vertices[0].z = 0;
2108 vertices[0].color = *color;
2109
2110 d3d_disp->device->SetFVF(D3DFVF_ALLEGRO_VERTEX);
2111 d3d_disp->effect->SetBool(ALLEGRO_SHADER_VAR_USE_TEX, false);
2112 d3d_disp->effect->Begin(&required_passes, 0);
2113 for (unsigned int i = 0; i < required_passes; i++) {
2114 d3d_disp->effect->BeginPass(i);
2115 if (d3d_disp->device->DrawPrimitiveUP(D3DPT_POINTLIST, 1,
2116 vertices, sizeof(ALLEGRO_VERTEX)) != D3D_OK) {
2117 ALLEGRO_ERROR("d3d_draw_pixel: DrawPrimitive failed.\n");
2118 return;
2119 }
2120 d3d_disp->effect->EndPass();
2121 }
2122 d3d_disp->effect->End();
2123 }
2124 else
2125 #endif
2126 {
2127 D3D_FIXED_VERTEX vertices[1];
2128 vertices[0].x = x;
2129 vertices[0].y = y;
2130 vertices[0].z = 0;
2131 vertices[0].color = D3DCOLOR_COLORVALUE(color->r, color->g, color->b, color->a);
2132
2133 d3d_disp->device->SetFVF(D3DFVF_FIXED_VERTEX);
2134 d3d_disp->device->SetTexture(0, NULL);
2135 if (d3d_disp->device->DrawPrimitiveUP(D3DPT_POINTLIST, 1,
2136 vertices, sizeof(D3D_FIXED_VERTEX)) != D3D_OK) {
2137 ALLEGRO_ERROR("d3d_draw_pixel: DrawPrimitive failed.\n");
2138 return;
2139 }
2140 }
2141 }
2142
2143 static void d3d_flip_display(ALLEGRO_DISPLAY *al_display)
2144 {
2145 ALLEGRO_DISPLAY_D3D* d3d_display = (ALLEGRO_DISPLAY_D3D*)al_display;
2146 ALLEGRO_DISPLAY_WIN *win_display = &d3d_display->win_display;
2147 HRESULT hr;
2148
2149 if (d3d_display->device_lost)
2150 return;
2151
2152 al_lock_mutex(present_mutex);
2153
2154 d3d_display->device->EndScene();
2155
2156 hr = d3d_display->device->Present(NULL, NULL, win_display->window, NULL);
2157
2158 d3d_display->device->BeginScene();
2159
2160 al_unlock_mutex(present_mutex);
2161
2162 if (hr == D3DERR_DEVICELOST) {
2163 d3d_display->device_lost = true;
2164 return;
2165 }
2166 else {
2167 al_backup_dirty_bitmaps(al_display);
2168 }
2169 }
2170
2171 static void d3d_update_display_region(ALLEGRO_DISPLAY *al_display,
2172 int x, int y,
2173 int width, int height)
2174 {
2175 ALLEGRO_DISPLAY_D3D* d3d_display = (ALLEGRO_DISPLAY_D3D*)al_display;
2176 ALLEGRO_DISPLAY_WIN *win_display = &d3d_display->win_display;
2177 HRESULT hr;
2178 RGNDATA *rgndata;
2179
2180 if (d3d_display->device_lost)
2181 return;
2182
2183 if (d3d_display->single_buffer) {
2184 RECT rect;
2185
2186 rect.left = x;
2187 rect.right = x+width;
2188 rect.top = y;
2189 rect.bottom = y+height;
2190
2191 rgndata = (RGNDATA *)al_malloc(sizeof(RGNDATA)+sizeof(RECT)-1);
2192 rgndata->rdh.dwSize = sizeof(RGNDATAHEADER);
2193 rgndata->rdh.iType = RDH_RECTANGLES;
2194 rgndata->rdh.nCount = 1;
2195 rgndata->rdh.nRgnSize = sizeof(RECT);
2196 memcpy(&rgndata->rdh.rcBound, &rect, sizeof(RECT));
2197 memcpy(rgndata->Buffer, &rect, sizeof(RECT));
2198
2199 d3d_display->device->EndScene();
2200
2201 hr = d3d_display->device->Present(&rect, &rect, win_display->window, rgndata);
2202
2203 d3d_display->device->BeginScene();
2204
2205 al_free(rgndata);
2206
2207 if (hr == D3DERR_DEVICELOST) {
2208 d3d_display->device_lost = true;
2209 return;
2210 }
2211 }
2212 else {
2213 d3d_flip_display(al_display);
2214 }
2215 }
2216
2217 /*
2218 * Sets a clipping rectangle
2219 */
2220 void _al_d3d_set_bitmap_clip(ALLEGRO_BITMAP *bitmap)
2221 {
2222 ALLEGRO_BITMAP_EXTRA_D3D *d3d_bmp = get_extra(bitmap);
2223 ALLEGRO_DISPLAY_D3D *disp = d3d_bmp->display;
2224 RECT rect;
2225
2226 if (!disp)
2227 return;
2228
2229 if (bitmap->parent) {
2230 rect.left = bitmap->xofs + bitmap->cl;
2231 rect.right = bitmap->xofs + bitmap->cr_excl;
2232 rect.top = bitmap->yofs + bitmap->ct;
2233 rect.bottom = bitmap->yofs + bitmap->cb_excl;
2234 }
2235 else {
2236 rect.left = bitmap->cl;
2237 rect.right = bitmap->cr_excl;
2238 rect.top = bitmap->ct;
2239 rect.bottom = bitmap->cb_excl;
2240 }
2241
2242 if (memcmp(&disp->scissor_state, &rect, sizeof(RECT)) != 0) {
2243
2244 if (rect.left == 0 && rect.top == 0 && rect.right == disp->win_display.display.w && rect.left == disp->win_display.display.h) {
2245 disp->device->SetRenderState(D3DRS_SCISSORTESTENABLE, false);
2246 return;
2247 }
2248
2249 disp->device->SetRenderState(D3DRS_SCISSORTESTENABLE, true);
2250 disp->device->SetScissorRect(&rect);
2251
2252 disp->scissor_state = rect;
2253 }
2254 }
2255
2256 static bool d3d_acknowledge_resize(ALLEGRO_DISPLAY *d)
2257 {
2258 WINDOWINFO wi;
2259 ALLEGRO_DISPLAY_D3D *disp = (ALLEGRO_DISPLAY_D3D *)d;
2260 ALLEGRO_DISPLAY_WIN *win_display = &disp->win_display;
2261 int w, h;
2262 ALLEGRO_STATE state;
2263
2264 wi.cbSize = sizeof(WINDOWINFO);
2265 GetWindowInfo(win_display->window, &wi);
2266 w = wi.rcClient.right - wi.rcClient.left;
2267 h = wi.rcClient.bottom - wi.rcClient.top;
2268
2269 if (w > 0 && h > 0) {
2270 d->w = w;
2271 d->h = h;
2272 }
2273
2274 disp->backbuffer_bmp.w = d->w;
2275 disp->backbuffer_bmp.h = d->h;
2276 disp->backbuffer_bmp.cl = 0;
2277 disp->backbuffer_bmp.ct = 0;
2278 disp->backbuffer_bmp.cr_excl = w;
2279 disp->backbuffer_bmp.cb_excl = h;
2280 al_identity_transform(&disp->backbuffer_bmp.proj_transform);
2281 al_orthographic_transform(&disp->backbuffer_bmp.proj_transform, 0, 0, -1.0, w, h, 1.0);
2282
2283 disp->do_reset = true;
2284 while (!disp->reset_done) {
2285 al_rest(0.001);
2286 }
2287 disp->reset_done = false;
2288
2289 /* XXX: This is not very efficient, it'd probably be better to call
2290 * the necessary functions directly. */
2291 al_store_state(&state, ALLEGRO_STATE_DISPLAY | ALLEGRO_STATE_TARGET_BITMAP);
2292 al_set_target_bitmap(al_get_backbuffer(d));
2293 al_set_clipping_rectangle(0, 0, d->w, d->h);
2294 al_restore_state(&state);
2295
2296 return disp->reset_success;
2297 }
2298
2299 static bool d3d_resize_helper(ALLEGRO_DISPLAY *d, int width, int height)
2300 {
2301 ALLEGRO_DISPLAY_D3D *disp = (ALLEGRO_DISPLAY_D3D *)d;
2302 ALLEGRO_DISPLAY_WIN *win_display = &disp->win_display;
2303 ALLEGRO_DISPLAY_D3D *new_disp;
2304 int full_w, full_h;
2305 ALLEGRO_MONITOR_INFO mi;
2306 int adapter = win_display->adapter;
2307
2308 ALLEGRO_STATE backup;
2309
2310 al_get_monitor_info(adapter, &mi);
2311 full_w = mi.x2 - mi.x1;
2312 full_h = mi.y2 - mi.y1;
2313
2314 if ((d->flags & ALLEGRO_FULLSCREEN_WINDOW) &&
2315 (full_w != width || full_h != height)) {
2316 win_display->toggle_w = width;
2317 win_display->toggle_h = height;
2318 return true;
2319 }
2320
2321 if (d->flags & ALLEGRO_FULLSCREEN) {
2322 /* Don't generate ALLEGRO_EVENT_DISPLAY_LOST events when destroying a
2323 * display for resizing.
2324 */
2325 disp->suppress_lost_events = true;
2326 d3d_destroy_display_internals(disp);
2327
2328 d->w = width;
2329 d->h = height;
2330 /* reset refresh rate (let new mode choose one) */
2331 d->refresh_rate = 0;
2332 win_display->end_thread = false;
2333 win_display->thread_ended = false;
2334 /* What's this? */
2335 ALLEGRO_SYSTEM *system = al_get_system_driver();
2336 if (system->displays._size <= 1) {
2337 ffw_set = false;
2338 }
2339 /* The original display needs to remain intact so we can
2340 * recover if resizing a display fails.
2341 */
2342 new_disp = d3d_create_display_internals(disp, false);
2343 if (!new_disp) {
2344 ALLEGRO_ERROR("d3d_create_display_internals failed.\n");
2345 ASSERT(d->vt);
2346 return false;
2347 }
2348 ASSERT(new_disp == disp);
2349 ASSERT(d->vt);
2350
2351 disp->suppress_lost_events = false;
2352
2353 _al_d3d_recreate_bitmap_textures(disp);
2354
2355 disp->backbuffer_bmp.w = width;
2356 disp->backbuffer_bmp.h = height;
2357
2358 }
2359 else {
2360 RECT win_size;
2361 WINDOWINFO wi;
2362
2363 win_size.left = 0;
2364 win_size.top = 0;
2365 win_size.right = width;
2366 win_size.bottom = height;
2367
2368 wi.cbSize = sizeof(WINDOWINFO);
2369 GetWindowInfo(win_display->window, &wi);
2370
2371 AdjustWindowRectEx(&win_size, wi.dwStyle, GetMenu(win_display->window) ? TRUE : FALSE, wi.dwExStyle);
2372
2373 // FIXME: Handle failure (for example if window constraints are active?)
2374 SetWindowPos(win_display->window, HWND_TOP,
2375 0, 0,
2376 win_size.right-win_size.left,
2377 win_size.bottom-win_size.top,
2378 SWP_NOMOVE|SWP_NOZORDER);
2379
2380 if (!(d->flags & ALLEGRO_FULLSCREEN_WINDOW)) {
2381 win_display->toggle_w = width;
2382 win_display->toggle_h = height;
2383 }
2384
2385 /*
2386 * The clipping rectangle and bitmap size must be
2387 * changed to match the new size.
2388 */
2389 al_store_state(&backup, ALLEGRO_STATE_TARGET_BITMAP);
2390 al_set_target_bitmap(&disp->backbuffer_bmp);
2391 disp->backbuffer_bmp.w = width;
2392 disp->backbuffer_bmp.h = height;
2393 al_set_clipping_rectangle(0, 0, width, height);
2394 _al_d3d_set_bitmap_clip(&disp->backbuffer_bmp);
2395 al_restore_state(&backup);
2396
2397 }
2398
2399 return true;
2400 }
2401
2402 static bool d3d_resize_display(ALLEGRO_DISPLAY *d, int width, int height)
2403 {
2404 ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)d;
2405 int orig_w = d->w;
2406 int orig_h = d->h;
2407 bool ret;
2408
2409 al_backup_dirty_bitmaps(d);
2410
2411 win_display->ignore_resize = true;
2412
2413 if (!d3d_resize_helper(d, width, height)) {
2414 ALLEGRO_WARN("trying to restore original size: %d, %d\n",
2415 orig_w, orig_h);
2416 if (!d3d_resize_helper(d, orig_w, orig_h)) {
2417 ALLEGRO_ERROR("failed to restore original size: %d, %d\n",
2418 orig_w, orig_h);
2419 }
2420 ret = false;
2421 } else {
2422 ret = true;
2423 d3d_acknowledge_resize(d);
2424 }
2425
2426 win_display->ignore_resize = false;
2427
2428 return ret;
2429 }
2430
2431 static ALLEGRO_BITMAP *d3d_create_bitmap(ALLEGRO_DISPLAY *d,
2432 int w, int h, int format, int flags)
2433 {
2434 ALLEGRO_BITMAP *bitmap;
2435 ALLEGRO_BITMAP_EXTRA_D3D *extra;
2436
2437 if (!_al_pixel_format_is_real(format)) {
2438 format = d3d_choose_bitmap_format((ALLEGRO_DISPLAY_D3D *)d, format);
2439 if (format < 0) {
2440 return NULL;
2441 }
2442 }
2443
2444 if (_al_pixel_format_to_d3d(format) < 0) {
2445 ALLEGRO_ERROR("Requested bitmap format not supported (%s).\n",
2446 _al_pixel_format_name((ALLEGRO_PIXEL_FORMAT)format));
2447 return NULL;
2448 }
2449
2450 if (!is_texture_format_ok(d, format)) {
2451 ALLEGRO_ERROR("Requested bitmap format not supported (%s).\n",
2452 _al_pixel_format_name((ALLEGRO_PIXEL_FORMAT)format));
2453 return NULL;
2454 }
2455
2456 bool compressed = _al_pixel_format_is_compressed(format);
2457 if (compressed) {
2458 if (!_al_d3d_render_to_texture_supported()) {
2459 /* Not implemented. XXX: Why not? */
2460 return NULL;
2461 }
2462 }
2463 int block_width = al_get_pixel_block_width(format);
2464 int block_height = al_get_pixel_block_height(format);
2465 int block_size = al_get_pixel_block_size(format);
2466
2467 ALLEGRO_INFO("Chose bitmap format %d\n", format);
2468
2469 bitmap = (ALLEGRO_BITMAP *)al_malloc(sizeof *bitmap);
2470 ASSERT(bitmap);
2471 memset(bitmap, 0, sizeof(*bitmap));
2472
2473 bitmap->vt = _al_bitmap_d3d_driver();
2474 bitmap->_format = format;
2475 bitmap->_flags = flags;
2476 al_identity_transform(&bitmap->transform);
2477
2478 bitmap->pitch =
2479 _al_get_least_multiple(w, block_width) / block_width * block_size;
2480 bitmap->memory = (unsigned char *)al_malloc(
2481 bitmap->pitch * _al_get_least_multiple(h, block_height) / block_height);
2482
2483 extra = (ALLEGRO_BITMAP_EXTRA_D3D *)al_calloc(1, sizeof *extra);
2484 bitmap->extra = extra;
2485 extra->video_texture = 0;
2486 extra->system_texture = 0;
2487 extra->initialized = false;
2488 extra->is_backbuffer = false;
2489 extra->render_target = NULL;
2490 extra->system_format = compressed ? ALLEGRO_PIXEL_FORMAT_ARGB_8888 : format;
2491
2492 extra->display = (ALLEGRO_DISPLAY_D3D *)d;
2493
2494 return bitmap;
2495 }
2496
2497 void _al_d3d_destroy_bitmap(ALLEGRO_BITMAP *bitmap)
2498 {
2499 ASSERT(!al_is_sub_bitmap(bitmap));
2500 ALLEGRO_DISPLAY_D3D *d3d_display = (ALLEGRO_DISPLAY_D3D*)_al_get_bitmap_display(bitmap);
2501
2502 if (bitmap == d3d_display->target_bitmap) {
2503 d3d_display->target_bitmap = NULL;
2504 }
2505
2506 ALLEGRO_BITMAP_EXTRA_D3D *d3d_bmp = get_extra(bitmap);
2507
2508 if (d3d_bmp->video_texture) {
2509 if (d3d_bmp->video_texture->Release() != 0) {
2510 ALLEGRO_WARN("d3d_destroy_bitmap: Release video texture failed.\n");
2511 }
2512 }
2513 if (d3d_bmp->system_texture) {
2514 if (d3d_bmp->system_texture->Release() != 0) {
2515 ALLEGRO_WARN("d3d_destroy_bitmap: Release system texture failed.\n");
2516 }
2517 }
2518
2519 if (d3d_bmp->render_target) {
2520 if (d3d_bmp->render_target->Release() != 0) {
2521 ALLEGRO_WARN("d3d_destroy_bitmap: Release render target failed.\n");
2522 }
2523 }
2524
2525 al_free(bitmap->extra);
2526 }
2527
2528 static void d3d_set_target_bitmap(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bitmap)
2529 {
2530 ALLEGRO_BITMAP *target;
2531 ALLEGRO_BITMAP_EXTRA_D3D *d3d_target;
2532 ALLEGRO_BITMAP_EXTRA_D3D *old_target = NULL;
2533 ALLEGRO_DISPLAY_D3D *d3d_display = (ALLEGRO_DISPLAY_D3D *)display;
2534
2535 if (d3d_display->device_lost)
2536 return;
2537
2538 if (bitmap->parent) {
2539 target = bitmap->parent;
2540 }
2541 else {
2542 target = bitmap;
2543 }
2544
2545 d3d_target = get_extra(target);
2546 if (d3d_display->target_bitmap)
2547 old_target = get_extra(d3d_display->target_bitmap);
2548
2549 /* Release the previous target bitmap if it was not the backbuffer */
2550 if (old_target && !old_target->is_backbuffer) {
2551 ALLEGRO_BITMAP *parent;
2552 if (d3d_display->target_bitmap->parent)
2553 parent = d3d_display->target_bitmap->parent;
2554 else
2555 parent = d3d_display->target_bitmap;
2556 ALLEGRO_BITMAP_EXTRA_D3D *e = get_extra(parent);
2557 if (e && e->render_target) {
2558 e->render_target->Release();
2559 e->render_target = NULL;
2560 }
2561 }
2562 d3d_display->target_bitmap = NULL;
2563
2564 /* Set the render target */
2565 if (d3d_target->is_backbuffer) {
2566 d3d_display = d3d_target->display;
2567 if (d3d_display->device->SetRenderTarget(0, d3d_display->render_target) != D3D_OK) {
2568 ALLEGRO_ERROR("d3d_set_target_bitmap: Unable to set render target to texture surface.\n");
2569 return;
2570 }
2571 d3d_target->render_target = d3d_display->render_target;
2572 d3d_display->target_bitmap = bitmap;
2573 }
2574 else if (_al_pixel_format_is_compressed(al_get_bitmap_format(target))) {
2575 /* Do nothing, as it is impossible to directly draw to compressed textures via D3D.
2576 * Instead, everything will be handled by the memory routines. */
2577 }
2578 else {
2579 d3d_display = (ALLEGRO_DISPLAY_D3D *)display;
2580 if (_al_d3d_render_to_texture_supported()) {
2581 d3d_display->target_bitmap = bitmap;
2582 if (!d3d_target->video_texture) {
2583 /* This can happen if the user tries to set the target bitmap as
2584 * the device is lost, before the DISPLAY_LOST event is received.
2585 */
2586 ALLEGRO_WARN("d3d_set_target_bitmap: No video texture.\n");
2587 return;
2588 }
2589 if (d3d_target->video_texture->GetSurfaceLevel(0, &d3d_target->render_target) != D3D_OK) {
2590 ALLEGRO_ERROR("d3d_set_target_bitmap: Unable to get texture surface level.\n");
2591 return;
2592 }
2593 if (d3d_display->device->SetRenderTarget(0, d3d_target->render_target) != D3D_OK) {
2594 ALLEGRO_ERROR("d3d_set_target_bitmap: Unable to set render target to texture surface.\n");
2595 d3d_target->render_target->Release();
2596 return;
2597 }
2598 }
2599 if (d3d_display->samples) {
2600 d3d_display->device->SetDepthStencilSurface(NULL);
2601 }
2602 }
2603
2604 d3d_reset_state(d3d_display);
2605
2606 _al_d3d_set_bitmap_clip(bitmap);
2607 }
2608
2609 static ALLEGRO_BITMAP *d3d_get_backbuffer(ALLEGRO_DISPLAY *display)
2610 {
2611 return (ALLEGRO_BITMAP *)&(((ALLEGRO_DISPLAY_D3D *)display)->backbuffer_bmp);
2612 }
2613
2614 static bool d3d_is_compatible_bitmap(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bitmap)
2615 {
2616 return display == _al_get_bitmap_display(bitmap);
2617 }
2618
2619 static void d3d_switch_out(ALLEGRO_DISPLAY *display)
2620 {
2621 (void)display;
2622 }
2623
2624 static void d3d_switch_in(ALLEGRO_DISPLAY *display)
2625 {
2626 (void)display;
2627 }
2628
2629 static bool d3d_wait_for_vsync(ALLEGRO_DISPLAY *display)
2630 {
2631 ALLEGRO_DISPLAY_D3D *d3d_display;
2632 D3DRASTER_STATUS status;
2633
2634 if (!d3d_can_wait_for_vsync)
2635 return false;
2636
2637 d3d_display = (ALLEGRO_DISPLAY_D3D *)display;
2638
2639 do {
2640 d3d_display->device->GetRasterStatus(0, &status);
2641 } while (!status.InVBlank);
2642
2643 return true;
2644 }
2645
2646
2647 /* Exposed stuff */
2648
2649 /* Function: al_get_d3d_device
2650 */
2651 LPDIRECT3DDEVICE9 al_get_d3d_device(ALLEGRO_DISPLAY *display)
2652 {
2653 ALLEGRO_DISPLAY_D3D *d3d_display = (ALLEGRO_DISPLAY_D3D *)display;
2654 return d3d_display->device;
2655 }
2656
2657 /* Function: al_get_d3d_system_texture
2658 */
2659 LPDIRECT3DTEXTURE9 al_get_d3d_system_texture(ALLEGRO_BITMAP *bitmap)
2660 {
2661 ALLEGRO_BITMAP_EXTRA_D3D *e = get_extra(bitmap);
2662 return e->system_texture;
2663 }
2664
2665 /* Function: al_get_d3d_video_texture
2666 */
2667 LPDIRECT3DTEXTURE9 al_get_d3d_video_texture(ALLEGRO_BITMAP *bitmap)
2668 {
2669 ALLEGRO_BITMAP_EXTRA_D3D *e = get_extra(bitmap);
2670 return e->video_texture;
2671 }
2672
2673 /* Function: al_get_d3d_texture_position
2674 */
2675 void al_get_d3d_texture_position(ALLEGRO_BITMAP *bitmap, int *u, int *v)
2676 {
2677 ASSERT(bitmap);
2678 ASSERT(u);
2679 ASSERT(v);
2680
2681 *u = bitmap->xofs;
2682 *v = bitmap->yofs;
2683 }
2684
2685 /* Function: al_is_d3d_device_lost
2686 */
2687 bool al_is_d3d_device_lost(ALLEGRO_DISPLAY *display)
2688 {
2689 return ((ALLEGRO_DISPLAY_D3D *)display)->device_lost;
2690 }
2691
2692 static void d3d_set_window_position(ALLEGRO_DISPLAY *display, int x, int y)
2693 {
2694 _al_win_set_window_position(((ALLEGRO_DISPLAY_WIN *)display)->window, x, y);
2695 }
2696
2697 static void d3d_get_window_position(ALLEGRO_DISPLAY *display, int *x, int *y)
2698 {
2699 if (display->flags & ALLEGRO_FULLSCREEN) {
2700 ALLEGRO_MONITOR_INFO info;
2701 ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)display;
2702 al_get_monitor_info(win_display->adapter, &info);
2703 *x = info.x1;
2704 *y = info.y1;
2705 }
2706 else {
2707 _al_win_get_window_position(((ALLEGRO_DISPLAY_WIN *)display)->window, x, y);
2708 }
2709 }
2710
2711
2712 void _al_d3d_shutdown_display(void)
2713 {
2714 if (!vt)
2715 return;
2716
2717 _al_d3d_destroy_display_format_list();
2718
2719 if (_al_d3d)
2720 _al_d3d->Release();
2721 al_destroy_mutex(present_mutex);
2722 al_destroy_mutex(_al_d3d_lost_device_mutex);
2723 al_destroy_mutex(primitives_mutex);
2724
2725 _al_d3d_bmp_destroy();
2726
2727 #ifdef ALLEGRO_CFG_SHADER_HLSL
2728 _al_d3d_shutdown_shaders();
2729 #endif
2730
2731 FreeLibrary(_al_d3d_module);
2732 _al_d3d_module = NULL;
2733
2734 #ifdef ALLEGRO_CFG_D3DX9
2735 _al_unload_d3dx9_module();
2736 #endif
2737
2738 al_free(vt);
2739 vt = NULL;
2740 }
2741
2742 static void* d3d_prepare_vertex_cache(ALLEGRO_DISPLAY* disp,
2743 int num_new_vertices)
2744 {
2745 int size;
2746
2747 if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
2748 size = sizeof(ALLEGRO_VERTEX);
2749 }
2750 else {
2751 size = sizeof(D3D_FIXED_VERTEX);
2752 }
2753
2754 disp->num_cache_vertices += num_new_vertices;
2755 if (!disp->vertex_cache) {
2756 disp->vertex_cache = al_malloc(num_new_vertices * size);
2757
2758 disp->vertex_cache_size = num_new_vertices;
2759 } else if (disp->num_cache_vertices > disp->vertex_cache_size) {
2760 disp->vertex_cache = al_realloc(disp->vertex_cache,
2761 2 * disp->num_cache_vertices * size);
2762
2763 disp->vertex_cache_size = 2 * disp->num_cache_vertices;
2764 }
2765 return (unsigned char *)disp->vertex_cache +
2766 (disp->num_cache_vertices - num_new_vertices) * size;
2767 }
2768
2769 static D3DTEXTUREADDRESS d3d_bitmap_wrap(ALLEGRO_BITMAP_WRAP wrap)
2770 {
2771 switch (wrap) {
2772 default:
2773 case ALLEGRO_BITMAP_WRAP_DEFAULT:
2774 return D3DTADDRESS_CLAMP;
2775 case ALLEGRO_BITMAP_WRAP_REPEAT:
2776 return D3DTADDRESS_WRAP;
2777 case ALLEGRO_BITMAP_WRAP_CLAMP:
2778 return D3DTADDRESS_CLAMP;
2779 case ALLEGRO_BITMAP_WRAP_MIRROR:
2780 return D3DTADDRESS_MIRROR;
2781 }
2782 }
2783
2784 void _al_set_d3d_sampler_state(IDirect3DDevice9* device, int sampler,
2785 ALLEGRO_BITMAP* bitmap, bool prim_default)
2786 {
2787 int bitmap_flags = al_get_bitmap_flags(bitmap);
2788 ALLEGRO_BITMAP_WRAP wrap_u, wrap_v;
2789 _al_get_bitmap_wrap(bitmap, &wrap_u, &wrap_v);
2790
2791 if (prim_default && wrap_u == ALLEGRO_BITMAP_WRAP_DEFAULT) {
2792 device->SetSamplerState(sampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
2793 }
2794 else {
2795 device->SetSamplerState(sampler, D3DSAMP_ADDRESSU, d3d_bitmap_wrap(wrap_u));
2796 }
2797
2798 if (prim_default && wrap_v == ALLEGRO_BITMAP_WRAP_DEFAULT) {
2799 device->SetSamplerState(sampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
2800 }
2801 else {
2802 device->SetSamplerState(sampler, D3DSAMP_ADDRESSV, d3d_bitmap_wrap(wrap_v));
2803 }
2804
2805 if (bitmap_flags & ALLEGRO_MIN_LINEAR) {
2806 device->SetSamplerState(sampler, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
2807 }
2808 else {
2809 device->SetSamplerState(sampler, D3DSAMP_MINFILTER, D3DTEXF_POINT);
2810 }
2811 if (bitmap_flags & ALLEGRO_MAG_LINEAR) {
2812 device->SetSamplerState(sampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
2813 }
2814 else {
2815 device->SetSamplerState(sampler, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
2816 }
2817 if (bitmap_flags & ALLEGRO_MIPMAP) {
2818 device->SetSamplerState(sampler, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
2819 }
2820 else {
2821 device->SetSamplerState(sampler, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2822 }
2823 }
2824
2825 static void d3d_flush_vertex_cache(ALLEGRO_DISPLAY* disp)
2826 {
2827 if (!disp->vertex_cache)
2828 return;
2829 if (disp->num_cache_vertices == 0)
2830 return;
2831
2832 ALLEGRO_DISPLAY_D3D* d3d_disp = (ALLEGRO_DISPLAY_D3D*)disp;
2833 ALLEGRO_BITMAP* cache_bmp = (ALLEGRO_BITMAP*)disp->cache_texture;
2834 ALLEGRO_BITMAP_EXTRA_D3D *d3d_bmp = get_extra(cache_bmp);
2835
2836 if (d3d_disp->device_lost)
2837 return;
2838
2839 _al_set_d3d_sampler_state(d3d_disp->device, 0, cache_bmp, false);
2840
2841 if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
2842 d3d_disp->device->SetFVF(D3DFVF_ALLEGRO_VERTEX);
2843 }
2844
2845 #ifdef ALLEGRO_CFG_SHADER_HLSL
2846 UINT required_passes;
2847 if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
2848 d3d_disp->effect->SetBool(ALLEGRO_SHADER_VAR_USE_TEX, true);
2849 d3d_disp->effect->SetTexture(ALLEGRO_SHADER_VAR_TEX, d3d_bmp->video_texture);
2850 d3d_disp->effect->Begin(&required_passes, 0);
2851 ASSERT(required_passes > 0);
2852 }
2853 #endif
2854
2855 if (d3d_disp->device->SetTexture(0, d3d_bmp->video_texture) != D3D_OK) {
2856 ALLEGRO_ERROR("d3d_flush_vertex_cache: SetTexture failed.\n");
2857 return;
2858 }
2859
2860 int size;
2861
2862 #ifdef ALLEGRO_CFG_SHADER_HLSL
2863 if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
2864 size = sizeof(ALLEGRO_VERTEX);
2865 for (unsigned int i = 0; i < required_passes; i++) {
2866 d3d_disp->effect->BeginPass(i);
2867 if (d3d_disp->device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, disp->num_cache_vertices / 3,
2868 (void *)disp->vertex_cache, size) != D3D_OK) {
2869 ALLEGRO_ERROR("d3d_flush_vertex_cache: DrawPrimitive failed.\n");
2870 return;
2871 }
2872 d3d_disp->effect->EndPass();
2873 }
2874 }
2875 else
2876 #endif
2877 {
2878 d3d_disp->device->SetFVF(D3DFVF_FIXED_VERTEX);
2879 size = sizeof(D3D_FIXED_VERTEX);
2880 if (d3d_disp->device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, disp->num_cache_vertices / 3,
2881 (void *)disp->vertex_cache, size) != D3D_OK) {
2882 ALLEGRO_ERROR("d3d_flush_vertex_cache: DrawPrimitive failed.\n");
2883 return;
2884 }
2885 }
2886
2887 disp->num_cache_vertices = 0;
2888 #ifdef ALLEGRO_CFG_SHADER_HLSL
2889 if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
2890 d3d_disp->effect->End();
2891 d3d_disp->effect->SetBool(ALLEGRO_SHADER_VAR_USE_TEX, false);
2892 d3d_disp->effect->SetTexture(ALLEGRO_SHADER_VAR_TEX, NULL);
2893 }
2894 #endif
2895
2896 d3d_disp->device->SetTexture(0, NULL);
2897 }
2898
2899 static void d3d_update_transformation(ALLEGRO_DISPLAY* disp, ALLEGRO_BITMAP *target)
2900 {
2901 ALLEGRO_DISPLAY_D3D* d3d_disp = (ALLEGRO_DISPLAY_D3D*)disp;
2902 ALLEGRO_TRANSFORM proj;
2903
2904 al_copy_transform(&proj, &target->proj_transform);
2905 /* Direct3D uses different clipping in projection space than OpenGL.
2906 * In OpenGL the final clip space is [-1..1] x [-1..1] x [-1..1].
2907 *
2908 * In D3D the clip space is [-1..1] x [-1..1] x [0..1].
2909 *
2910 * So we need to scale and translate the final z component from [-1..1]
2911 * to [0..1]. We do that by scaling with 0.5 then translating by 0.5
2912 * below.
2913 *
2914 * The effect can be seen for example ex_projection - it is broken
2915 * without this.
2916 */
2917 ALLEGRO_TRANSFORM fix_d3d;
2918 al_identity_transform(&fix_d3d);
2919 al_scale_transform_3d(&fix_d3d, 1, 1, 0.5);
2920 al_translate_transform_3d(&fix_d3d, 0.0, 0.0, 0.5);
2921 /*
2922 * Shift by half a pixel to make the output match the OpenGL output.
2923 * Don't shift the actual proj_transform because if the user grabs it via
2924 * al_get_current_projection_transform() and then sends it to
2925 * al_use_projection_transform() the shift will be applied twice.
2926 */
2927 al_translate_transform(&fix_d3d, -1.0 / al_get_bitmap_width(target),
2928 1.0 / al_get_bitmap_height(target));
2929
2930 al_compose_transform(&proj, &fix_d3d);
2931
2932 ALLEGRO_TRANSFORM projview;
2933 al_copy_transform(&projview, &target->transform);
2934 al_compose_transform(&projview, &proj);
2935 al_copy_transform(&disp->projview_transform, &projview);
2936 if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
2937 #ifdef ALLEGRO_CFG_SHADER_HLSL
2938 if (d3d_disp->effect)
2939 _al_hlsl_set_projview_matrix(d3d_disp->effect, &projview);
2940 #endif
2941 }
2942 else {
2943 d3d_disp->device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)proj.m);
2944 d3d_disp->device->SetTransform(D3DTS_VIEW, (D3DMATRIX *)target->transform.m);
2945 }
2946
2947 D3DVIEWPORT9 viewport;
2948 viewport.MinZ = 0;
2949 viewport.MaxZ = 1;
2950 viewport.Width = al_get_bitmap_width(target);
2951 viewport.Height = al_get_bitmap_height(target);
2952 if (target->parent) {
2953 viewport.X = target->xofs;
2954 viewport.Y = target->yofs;
2955 }
2956 else {
2957 viewport.X = 0;
2958 viewport.Y = 0;
2959 }
2960 d3d_disp->device->SetViewport(&viewport);
2961 }
2962
2963 static void* convert_to_fixed_vertices(const void* vtxs, int num_vertices, const int* indices, bool loop, bool use_programmable_pipeline)
2964 {
2965 const ALLEGRO_VERTEX* vtx = (const ALLEGRO_VERTEX *)vtxs;
2966 int ii;
2967 int num_needed_vertices = num_vertices;
2968 size_t needed_size;
2969
2970 if (use_programmable_pipeline && !indices && !loop) {
2971 return (void *)vtxs;
2972 }
2973
2974 if(loop)
2975 num_needed_vertices++;
2976
2977 needed_size = num_needed_vertices * (use_programmable_pipeline ? sizeof(ALLEGRO_VERTEX) : sizeof(D3D_FIXED_VERTEX));
2978
2979 if(fixed_buffer == 0) {
2980 fixed_buffer = (char *)al_malloc(needed_size);
2981 fixed_buffer_size = needed_size;
2982 } else if (needed_size > fixed_buffer_size) {
2983 size_t new_size = needed_size * 1.5;
2984 fixed_buffer = (char *)al_realloc(fixed_buffer, new_size);
2985 fixed_buffer_size = new_size;
2986 }
2987
2988 if (use_programmable_pipeline) {
2989 ALLEGRO_VERTEX *buffer = (ALLEGRO_VERTEX*)fixed_buffer;
2990 for(ii = 0; ii < num_vertices; ii++) {
2991 if(indices)
2992 buffer[ii] = vtx[indices[ii]];
2993 else
2994 buffer[ii] = vtx[ii];
2995 }
2996 if(loop)
2997 buffer[num_vertices] = buffer[0];
2998 }
2999 else {
3000 D3D_FIXED_VERTEX *buffer = (D3D_FIXED_VERTEX*)fixed_buffer;
3001 for(ii = 0; ii < num_vertices; ii++) {
3002 ALLEGRO_VERTEX vertex;
3003
3004 if(indices)
3005 vertex = vtx[indices[ii]];
3006 else
3007 vertex = vtx[ii];
3008
3009 buffer[ii].x = vertex.x;
3010 buffer[ii].y = vertex.y;
3011 buffer[ii].z = vertex.z;
3012
3013 buffer[ii].u = vertex.u;
3014 buffer[ii].v = vertex.v;
3015
3016 buffer[ii].color = D3DCOLOR_COLORVALUE(vertex.color.r, vertex.color.g, vertex.color.b, vertex.color.a);
3017 }
3018 if(loop)
3019 buffer[num_vertices] = buffer[0];
3020 }
3021
3022 return fixed_buffer;
3023 }
3024
3025 struct D3D_STATE
3026 {
3027 DWORD old_wrap_state[2];
3028 DWORD old_ttf_state;
3029 IDirect3DVertexShader9* old_vtx_shader;
3030 };
3031
3032 static D3D_STATE setup_state(LPDIRECT3DDEVICE9 device, const ALLEGRO_VERTEX_DECL* decl, ALLEGRO_BITMAP* texture, ALLEGRO_DISPLAY* disp)
3033 {
3034 D3D_STATE state = {};
3035 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)disp;
3036 bool use_programmable_pipeline = disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE;
3037 bool use_default_shader = false;
3038
3039 if (!use_programmable_pipeline) {
3040 /* Manually set the shader without D3DX. */
3041 IDirect3DPixelShader9* old_pix_shader;
3042 device->GetPixelShader(&old_pix_shader);
3043 if (!old_pix_shader) {
3044 _al_d3d_set_blender(d3d_disp);
3045 }
3046
3047 device->GetVertexShader(&state.old_vtx_shader);
3048 use_default_shader = state.old_vtx_shader == NULL;
3049 if (use_default_shader) {
3050 if (!use_fixed_pipeline) {
3051 device->SetVertexShader(d3d_disp->primitives_shader);
3052 /* See prim_directx_shader.inc */
3053 device->SetVertexShaderConstantF(0, (float*)&disp->projview_transform, 4);
3054 }
3055 }
3056 }
3057 else {
3058 state.old_vtx_shader = NULL;
3059 _al_d3d_set_blender(d3d_disp);
3060 }
3061
3062 /* Set the vertex declarations */
3063 if (use_fixed_pipeline && !use_programmable_pipeline) {
3064 device->SetFVF(D3DFVF_FIXED_VERTEX);
3065 }
3066 else {
3067 if(decl) {
3068 device->SetVertexDeclaration((IDirect3DVertexDeclaration9*)decl->d3d_decl);
3069 }
3070 else {
3071 device->SetFVF(D3DFVF_ALLEGRO_VERTEX);
3072 }
3073 }
3074
3075 /* Set up the texture */
3076 if (use_default_shader || use_programmable_pipeline) {
3077 if (texture) {
3078 LPDIRECT3DTEXTURE9 d3d_texture;
3079 int tex_x, tex_y;
3080 D3DSURFACE_DESC desc;
3081 float mat[4][4] = {
3082 {1, 0, 0, 0},
3083 {0, 1, 0, 0},
3084 {0, 0, 1, 0},
3085 {0, 0, 0, 1}
3086 };
3087
3088 d3d_texture = al_get_d3d_video_texture(texture);
3089
3090 d3d_texture->GetLevelDesc(0, &desc);
3091 al_get_d3d_texture_position(texture, &tex_x, &tex_y);
3092
3093 if(decl) {
3094 if(decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL].attribute) {
3095 mat[0][0] = 1.0f / desc.Width;
3096 mat[1][1] = 1.0f / desc.Height;
3097 } else {
3098 mat[0][0] = (float)al_get_bitmap_width(texture) / desc.Width;
3099 mat[1][1] = (float)al_get_bitmap_height(texture) / desc.Height;
3100 }
3101 } else {
3102 mat[0][0] = 1.0f / desc.Width;
3103 mat[1][1] = 1.0f / desc.Height;
3104 }
3105 mat[2][0] = (float)tex_x / desc.Width;
3106 mat[2][1] = (float)tex_y / desc.Height;
3107
3108 if (use_programmable_pipeline) {
3109 #ifdef ALLEGRO_CFG_SHADER_HLSL
3110 d3d_disp->effect->SetMatrix(ALLEGRO_SHADER_VAR_TEX_MATRIX, (D3DXMATRIX *)mat);
3111 d3d_disp->effect->SetBool(ALLEGRO_SHADER_VAR_USE_TEX_MATRIX, true);
3112 d3d_disp->effect->SetBool(ALLEGRO_SHADER_VAR_USE_TEX, true);
3113 d3d_disp->effect->SetTexture(ALLEGRO_SHADER_VAR_TEX, d3d_texture);
3114 #endif
3115 }
3116 else {
3117 if (use_fixed_pipeline) {
3118 device->GetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, &state.old_ttf_state);
3119 device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3120 device->SetTransform(D3DTS_TEXTURE0, (D3DMATRIX *)mat);
3121 }
3122 else {
3123 /* See prim_directx_shader.inc */
3124 float use_tex_matrix[4] = {1.0, 0., 0., 0.};
3125 device->SetVertexShaderConstantF(4, (float*)mat, 3);
3126 device->SetVertexShaderConstantF(8, use_tex_matrix, 1);
3127 }
3128 }
3129
3130 device->SetTexture(0, d3d_texture);
3131 }
3132 else {
3133 /* Don't unbind the texture here if shaders are used, since the user may
3134 * have set the 0'th texture unit manually via the shader API. */
3135 if (!use_programmable_pipeline) {
3136 device->SetTexture(0, NULL);
3137 }
3138 }
3139 }
3140
3141 if (texture) {
3142 device->GetSamplerState(0, D3DSAMP_ADDRESSU, &state.old_wrap_state[0]);
3143 device->GetSamplerState(0, D3DSAMP_ADDRESSV, &state.old_wrap_state[1]);
3144 _al_set_d3d_sampler_state(device, 0, texture, true);
3145 }
3146
3147 return state;
3148 }
3149
3150 static void revert_state(D3D_STATE state, LPDIRECT3DDEVICE9 device, ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture)
3151 {
3152 ALLEGRO_DISPLAY *disp = _al_get_bitmap_display(target);
3153 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)disp;
3154 (void)d3d_disp;
3155 bool use_programmable_pipeline = disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE;
3156 bool use_default_shader = state.old_vtx_shader == NULL;
3157
3158 if (use_programmable_pipeline) {
3159 #ifdef ALLEGRO_CFG_SHADER_HLSL
3160 d3d_disp->effect->End();
3161 d3d_disp->effect->SetBool(ALLEGRO_SHADER_VAR_USE_TEX_MATRIX, false);
3162 d3d_disp->effect->SetBool(ALLEGRO_SHADER_VAR_USE_TEX, false);
3163 #endif
3164 }
3165
3166 if (texture) {
3167 device->SetSamplerState(0, D3DSAMP_ADDRESSU, state.old_wrap_state[0]);
3168 device->SetSamplerState(0, D3DSAMP_ADDRESSV, state.old_wrap_state[1]);
3169 }
3170
3171 if (texture && use_default_shader && use_fixed_pipeline) {
3172 device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, state.old_ttf_state);
3173 }
3174
3175 if (!use_programmable_pipeline && use_default_shader) {
3176 device->SetVertexShader(0);
3177 }
3178 }
3179
3180 static int draw_prim_common(ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture,
3181 const void* vtx, const ALLEGRO_VERTEX_DECL* decl,
3182 const int* indices, int num_vtx, int type)
3183 {
3184 int stride;
3185 int num_primitives = 0;
3186 LPDIRECT3DDEVICE9 device;
3187 int min_idx = 0, max_idx = num_vtx - 1;
3188 ALLEGRO_DISPLAY *disp = _al_get_bitmap_display(target);
3189 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)disp;
3190 UINT required_passes = 1;
3191 unsigned int i;
3192 D3D_STATE state;
3193 bool use_programmable_pipeline = disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE;
3194
3195 if (al_is_d3d_device_lost(disp)) {
3196 return 0;
3197 }
3198
3199 if (use_fixed_pipeline && !use_programmable_pipeline) {
3200 stride = (int)sizeof(D3D_FIXED_VERTEX);
3201 }
3202 else {
3203 stride = (decl ? decl->stride : (int)sizeof(ALLEGRO_VERTEX));
3204 }
3205
3206 if ((use_fixed_pipeline && decl) || (decl && decl->d3d_decl == 0)) {
3207 if(!indices)
3208 return _al_draw_prim_soft(texture, vtx, decl, 0, num_vtx, type);
3209 else
3210 return _al_draw_prim_indexed_soft(texture, vtx, decl, indices, num_vtx, type);
3211 }
3212
3213 int num_idx = num_vtx;
3214 if(indices)
3215 {
3216 int ii;
3217 for(ii = 0; ii < num_vtx; ii++)
3218 {
3219 int idx = indices[ii];
3220 if(ii == 0) {
3221 min_idx = idx;
3222 max_idx = idx;
3223 } else if (idx < min_idx) {
3224 min_idx = idx;
3225 } else if (idx > max_idx) {
3226 max_idx = idx;
3227 }
3228 }
3229 num_idx = max_idx + 1 - min_idx;
3230 }
3231
3232 device = al_get_d3d_device(disp);
3233
3234 state = setup_state(device, decl, texture, disp);
3235
3236 /* Convert vertices for legacy cards */
3237 if(use_fixed_pipeline) {
3238 al_lock_mutex(primitives_mutex);
3239 vtx = convert_to_fixed_vertices(vtx, num_vtx, indices, type == ALLEGRO_PRIM_LINE_LOOP,
3240 use_programmable_pipeline);
3241 }
3242
3243 #ifdef ALLEGRO_CFG_SHADER_HLSL
3244 if (use_programmable_pipeline) {
3245 d3d_disp->effect->Begin(&required_passes, 0);
3246 }
3247 #endif
3248
3249 for (i = 0; i < required_passes; i++) {
3250 #ifdef ALLEGRO_CFG_SHADER_HLSL
3251 if (use_programmable_pipeline) {
3252 d3d_disp->effect->BeginPass(i);
3253 }
3254 #endif
3255
3256 if (!indices || use_fixed_pipeline)
3257 {
3258 switch (type) {
3259 case ALLEGRO_PRIM_LINE_LIST: {
3260 num_primitives = num_vtx / 2;
3261 device->DrawPrimitiveUP(D3DPT_LINELIST, num_primitives, vtx, stride);
3262 break;
3263 };
3264 case ALLEGRO_PRIM_LINE_STRIP: {
3265 num_primitives = num_vtx - 1;
3266 device->DrawPrimitiveUP(D3DPT_LINESTRIP, num_primitives, vtx, stride);
3267 break;
3268 };
3269 case ALLEGRO_PRIM_LINE_LOOP: {
3270 num_primitives = num_vtx - 1;
3271 device->DrawPrimitiveUP(D3DPT_LINESTRIP, num_primitives, vtx, stride);
3272 if(!use_fixed_pipeline) {
3273 int in[2];
3274 in[0] = 0;
3275 in[1] = num_vtx-1;
3276
3277 device->DrawIndexedPrimitiveUP(D3DPT_LINELIST, 0, num_vtx, 1, in, D3DFMT_INDEX32, vtx, stride);
3278 } else {
3279 device->DrawPrimitiveUP(D3DPT_LINELIST, 1, (char*)vtx + stride * (num_vtx - 1), stride);
3280 }
3281 break;
3282 };
3283 case ALLEGRO_PRIM_TRIANGLE_LIST: {
3284 num_primitives = num_vtx / 3;
3285 device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, num_primitives, vtx, stride);
3286 break;
3287 };
3288 case ALLEGRO_PRIM_TRIANGLE_STRIP: {
3289 num_primitives = num_vtx - 2;
3290 device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, num_primitives, vtx, stride);
3291 break;
3292 };
3293 case ALLEGRO_PRIM_TRIANGLE_FAN: {
3294 num_primitives = num_vtx - 2;
3295 device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, num_primitives, vtx, stride);
3296 break;
3297 };
3298 case ALLEGRO_PRIM_POINT_LIST: {
3299 num_primitives = num_vtx;
3300 device->DrawPrimitiveUP(D3DPT_POINTLIST, num_primitives, vtx, stride);
3301 break;
3302 };
3303 }
3304 } else {
3305 switch (type) {
3306 case ALLEGRO_PRIM_LINE_LIST: {
3307 num_primitives = num_vtx / 2;
3308 device->DrawIndexedPrimitiveUP(D3DPT_LINELIST, min_idx, num_idx, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
3309 break;
3310 };
3311 case ALLEGRO_PRIM_LINE_STRIP: {
3312 num_primitives = num_vtx - 1;
3313 device->DrawIndexedPrimitiveUP(D3DPT_LINESTRIP, min_idx, num_idx, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
3314 break;
3315 };
3316 case ALLEGRO_PRIM_LINE_LOOP: {
3317 int in[2];
3318 num_primitives = num_vtx - 1;
3319 device->DrawIndexedPrimitiveUP(D3DPT_LINESTRIP, min_idx, num_idx, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
3320
3321 in[0] = indices[0];
3322 in[1] = indices[num_vtx-1];
3323 min_idx = in[0] > in[1] ? in[1] : in[0];
3324 max_idx = in[0] > in[1] ? in[0] : in[1];
3325 num_idx = max_idx - min_idx + 1;
3326 device->DrawIndexedPrimitiveUP(D3DPT_LINELIST, min_idx, num_idx, 1, in, D3DFMT_INDEX32, vtx, stride);
3327 break;
3328 };
3329 case ALLEGRO_PRIM_TRIANGLE_LIST: {
3330 num_primitives = num_vtx / 3;
3331 device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, min_idx, num_idx, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
3332 break;
3333 };
3334 case ALLEGRO_PRIM_TRIANGLE_STRIP: {
3335 num_primitives = num_vtx - 2;
3336 device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLESTRIP, min_idx, num_idx, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
3337 break;
3338 };
3339 case ALLEGRO_PRIM_TRIANGLE_FAN: {
3340 num_primitives = num_vtx - 2;
3341 device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLEFAN, min_idx, num_idx, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
3342 break;
3343 };
3344 case ALLEGRO_PRIM_POINT_LIST: {
3345 /*
3346 * D3D does not support point lists in indexed mode, so we draw them using the non-indexed mode. To gain at least a semblance
3347 * of speed, we detect consecutive runs of vertices and draw them using a single DrawPrimitiveUP call
3348 */
3349 int ii = 0;
3350 int start_idx = indices[0];
3351 int run_length = 0;
3352 for(ii = 0; ii < num_vtx; ii++)
3353 {
3354 run_length++;
3355 if(indices[ii] + 1 != indices[ii + 1] || ii == num_vtx - 1) {
3356 device->DrawPrimitiveUP(D3DPT_POINTLIST, run_length, (const char*)vtx + start_idx * stride, stride);
3357 if(ii != num_vtx - 1)
3358 start_idx = indices[ii + 1];
3359 run_length = 0;
3360 }
3361 }
3362 break;
3363 };
3364 }
3365 }
3366 #ifdef ALLEGRO_CFG_SHADER_HLSL
3367 if (use_programmable_pipeline) {
3368 d3d_disp->effect->EndPass();
3369 }
3370 #endif
3371 }
3372
3373 if(use_fixed_pipeline)
3374 al_unlock_mutex(primitives_mutex);
3375
3376 revert_state(state, device, target, texture);
3377
3378 return num_primitives;
3379 }
3380
3381 static int d3d_draw_prim(ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture, const void* vtxs, const ALLEGRO_VERTEX_DECL* decl, int start, int end, int type)
3382 {
3383 int stride = decl ? decl->stride : (int)sizeof(ALLEGRO_VERTEX);
3384 return draw_prim_common(target, texture, (const char*)vtxs + start * stride, decl, 0, end - start, type);
3385 }
3386
3387 static int d3d_draw_prim_indexed(ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture, const void* vtxs, const ALLEGRO_VERTEX_DECL* decl, const int* indices, int num_vtx, int type)
3388 {
3389 return draw_prim_common(target, texture, vtxs, decl, indices, num_vtx, type);
3390 }
3391
3392 static int draw_buffer_common(ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture, ALLEGRO_VERTEX_BUFFER* vertex_buffer, ALLEGRO_INDEX_BUFFER* index_buffer, int start, int end, int type)
3393 {
3394 int num_primitives = 0;
3395 int num_vtx = end - start;
3396 LPDIRECT3DDEVICE9 device;
3397 ALLEGRO_DISPLAY *disp = _al_get_bitmap_display(target);
3398 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)disp;
3399 UINT required_passes = 1;
3400 unsigned int i;
3401 D3D_STATE state;
3402 bool use_programmable_pipeline = disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE;
3403
3404 if (al_is_d3d_device_lost(disp)) {
3405 return 0;
3406 }
3407
3408 if (vertex_buffer->decl && vertex_buffer->decl->d3d_decl == 0) {
3409 return _al_draw_buffer_common_soft(vertex_buffer, texture, index_buffer, start, end, type);
3410 }
3411
3412 device = al_get_d3d_device(disp);
3413
3414 state = setup_state(device, vertex_buffer->decl, texture, disp);
3415
3416 device->SetStreamSource(0, (IDirect3DVertexBuffer9*)vertex_buffer->common.handle, 0, vertex_buffer->decl ? vertex_buffer->decl->stride : (int)sizeof(ALLEGRO_VERTEX));
3417
3418 if (index_buffer) {
3419 device->SetIndices((IDirect3DIndexBuffer9*)index_buffer->common.handle);
3420 }
3421
3422 #ifdef ALLEGRO_CFG_SHADER_HLSL
3423 if (use_programmable_pipeline) {
3424 d3d_disp->effect->Begin(&required_passes, 0);
3425 }
3426 #endif
3427
3428 for (i = 0; i < required_passes; i++) {
3429 #ifdef ALLEGRO_CFG_SHADER_HLSL
3430 if (use_programmable_pipeline) {
3431 d3d_disp->effect->BeginPass(i);
3432 }
3433 #endif
3434
3435 if (!index_buffer) {
3436 switch (type) {
3437 case ALLEGRO_PRIM_LINE_LIST: {
3438 num_primitives = num_vtx / 2;
3439 device->DrawPrimitive(D3DPT_LINELIST, start, num_primitives);
3440 break;
3441 };
3442 case ALLEGRO_PRIM_LINE_STRIP: {
3443 num_primitives = num_vtx - 1;
3444 device->DrawPrimitive(D3DPT_LINESTRIP, start, num_primitives);
3445 break;
3446 };
3447 case ALLEGRO_PRIM_LINE_LOOP: {
3448 num_primitives = num_vtx - 1;
3449 device->DrawPrimitive(D3DPT_LINESTRIP, start, num_primitives);
3450
3451 if (d3d_disp->loop_index_buffer) {
3452 int *indices;
3453 al_lock_mutex(primitives_mutex);
3454 d3d_disp->loop_index_buffer->Lock(0, 0, (void**)&indices, 0);
3455 ASSERT(indices);
3456 indices[0] = start;
3457 indices[1] = start + num_vtx - 1;
3458 d3d_disp->loop_index_buffer->Unlock();
3459 device->SetIndices(d3d_disp->loop_index_buffer);
3460 device->DrawIndexedPrimitive(D3DPT_LINESTRIP, 0, 0, _al_get_vertex_buffer_size(vertex_buffer), 0, 1);
3461 al_unlock_mutex(primitives_mutex);
3462 }
3463 break;
3464 };
3465 case ALLEGRO_PRIM_TRIANGLE_LIST: {
3466 num_primitives = num_vtx / 3;
3467 device->DrawPrimitive(D3DPT_TRIANGLELIST, start, num_primitives);
3468 break;
3469 };
3470 case ALLEGRO_PRIM_TRIANGLE_STRIP: {
3471 num_primitives = num_vtx - 2;
3472 device->DrawPrimitive(D3DPT_TRIANGLESTRIP, start, num_primitives);
3473 break;
3474 };
3475 case ALLEGRO_PRIM_TRIANGLE_FAN: {
3476 num_primitives = num_vtx - 2;
3477 device->DrawPrimitive(D3DPT_TRIANGLEFAN, start, num_primitives);
3478 break;
3479 };
3480 case ALLEGRO_PRIM_POINT_LIST: {
3481 num_primitives = num_vtx;
3482 device->DrawPrimitive(D3DPT_POINTLIST, start, num_primitives);
3483 break;
3484 };
3485 }
3486 }
3487 else {
3488 int vbuff_size = _al_get_vertex_buffer_size(vertex_buffer);
3489 switch (type) {
3490 case ALLEGRO_PRIM_LINE_LIST: {
3491 num_primitives = num_vtx / 2;
3492 device->DrawIndexedPrimitive(D3DPT_LINELIST, 0, 0, vbuff_size, start, num_primitives);
3493 break;
3494 };
3495 case ALLEGRO_PRIM_LINE_STRIP: {
3496 num_primitives = num_vtx - 1;
3497 device->DrawIndexedPrimitive(D3DPT_LINESTRIP, 0, 0, vbuff_size, start, num_primitives);
3498 break;
3499 };
3500 case ALLEGRO_PRIM_LINE_LOOP: {
3501 /* Unimplemented, too hard to do in a consistent fashion. */
3502 break;
3503 };
3504 case ALLEGRO_PRIM_TRIANGLE_LIST: {
3505 num_primitives = num_vtx / 3;
3506 device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, vbuff_size, start, num_primitives);
3507 break;
3508 };
3509 case ALLEGRO_PRIM_TRIANGLE_STRIP: {
3510 num_primitives = num_vtx - 2;
3511 device->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, vbuff_size, start, num_primitives);
3512 break;
3513 };
3514 case ALLEGRO_PRIM_TRIANGLE_FAN: {
3515 num_primitives = num_vtx - 2;
3516 device->DrawIndexedPrimitive(D3DPT_TRIANGLEFAN, 0, 0, vbuff_size, start, num_primitives);
3517 break;
3518 };
3519 case ALLEGRO_PRIM_POINT_LIST: {
3520 /* Unimplemented, too hard to do in a consistent fashion. */
3521 break;
3522 };
3523 }
3524 }
3525
3526 #ifdef ALLEGRO_CFG_SHADER_HLSL
3527 if (use_programmable_pipeline) {
3528 d3d_disp->effect->EndPass();
3529 }
3530 #endif
3531 }
3532
3533 revert_state(state, device, target, texture);
3534
3535 return num_primitives;
3536 }
3537
3538 static int d3d_draw_vertex_buffer(ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture, ALLEGRO_VERTEX_BUFFER* vertex_buffer, int start, int end, int type)
3539 {
3540 return draw_buffer_common(target, texture, vertex_buffer, NULL, start, end, type);
3541 }
3542
3543 static int d3d_draw_indexed_buffer(ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture, ALLEGRO_VERTEX_BUFFER* vertex_buffer, ALLEGRO_INDEX_BUFFER* index_buffer, int start, int end, int type)
3544 {
3545 return draw_buffer_common(target, texture, vertex_buffer, index_buffer, start, end, type);
3546 }
3547
3548 static int convert_storage(int storage)
3549 {
3550 switch(storage) {
3551 case ALLEGRO_PRIM_FLOAT_2:
3552 return D3DDECLTYPE_FLOAT2;
3553 break;
3554 case ALLEGRO_PRIM_FLOAT_3:
3555 return D3DDECLTYPE_FLOAT3;
3556 break;
3557 case ALLEGRO_PRIM_SHORT_2:
3558 return D3DDECLTYPE_SHORT2;
3559 break;
3560 case ALLEGRO_PRIM_FLOAT_1:
3561 return D3DDECLTYPE_FLOAT1;
3562 break;
3563 case ALLEGRO_PRIM_FLOAT_4:
3564 return D3DDECLTYPE_FLOAT4;
3565 break;
3566 case ALLEGRO_PRIM_UBYTE_4:
3567 return D3DDECLTYPE_UBYTE4;
3568 break;
3569 case ALLEGRO_PRIM_SHORT_4:
3570 return D3DDECLTYPE_SHORT4;
3571 break;
3572 case ALLEGRO_PRIM_NORMALIZED_UBYTE_4:
3573 return D3DDECLTYPE_UBYTE4N;
3574 break;
3575 case ALLEGRO_PRIM_NORMALIZED_SHORT_2:
3576 return D3DDECLTYPE_SHORT2N;
3577 break;
3578 case ALLEGRO_PRIM_NORMALIZED_SHORT_4:
3579 return D3DDECLTYPE_SHORT4N;
3580 break;
3581 case ALLEGRO_PRIM_NORMALIZED_USHORT_2:
3582 return D3DDECLTYPE_USHORT2N;
3583 break;
3584 case ALLEGRO_PRIM_NORMALIZED_USHORT_4:
3585 return D3DDECLTYPE_USHORT4N;
3586 break;
3587 case ALLEGRO_PRIM_HALF_FLOAT_2:
3588 return D3DDECLTYPE_FLOAT16_2;
3589 break;
3590 case ALLEGRO_PRIM_HALF_FLOAT_4:
3591 return D3DDECLTYPE_FLOAT16_4;
3592 break;
3593 default:
3594 ASSERT(0);
3595 return D3DDECLTYPE_UNUSED;
3596 }
3597 }
3598
3599 static bool d3d_create_vertex_decl(ALLEGRO_DISPLAY* display, ALLEGRO_VERTEX_DECL* decl)
3600 {
3601 LPDIRECT3DDEVICE9 device;
3602 D3DVERTEXELEMENT9 d3delements[ALLEGRO_PRIM_ATTR_NUM + 1];
3603 int idx = 0;
3604 ALLEGRO_VERTEX_ELEMENT* e;
3605 D3DCAPS9 caps;
3606
3607 device = al_get_d3d_device(display);
3608
3609 device->GetDeviceCaps(&caps);
3610 if(caps.PixelShaderVersion < D3DPS_VERSION(3, 0)) {
3611 decl->d3d_decl = 0;
3612 } else {
3613 int i;
3614 e = &decl->elements[ALLEGRO_PRIM_POSITION];
3615 if(e->attribute) {
3616 d3delements[idx].Stream = 0;
3617 d3delements[idx].Offset = e->offset;
3618 d3delements[idx].Type = convert_storage(e->storage);
3619 d3delements[idx].Method = D3DDECLMETHOD_DEFAULT;
3620 d3delements[idx].Usage = D3DDECLUSAGE_POSITION;
3621 d3delements[idx].UsageIndex = 0;
3622 idx++;
3623 }
3624
3625 e = &decl->elements[ALLEGRO_PRIM_TEX_COORD];
3626 if(!e->attribute)
3627 e = &decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL];
3628 if(e->attribute) {
3629 d3delements[idx].Stream = 0;
3630 d3delements[idx].Offset = e->offset;
3631 d3delements[idx].Type = convert_storage(e->storage);
3632 d3delements[idx].Method = D3DDECLMETHOD_DEFAULT;
3633 d3delements[idx].Usage = D3DDECLUSAGE_TEXCOORD;
3634 d3delements[idx].UsageIndex = 0;
3635 idx++;
3636 }
3637
3638 e = &decl->elements[ALLEGRO_PRIM_COLOR_ATTR];
3639 if(e->attribute) {
3640 d3delements[idx].Stream = 0;
3641 d3delements[idx].Offset = e->offset;
3642 d3delements[idx].Type = D3DDECLTYPE_FLOAT4;
3643 d3delements[idx].Method = D3DDECLMETHOD_DEFAULT;
3644 d3delements[idx].Usage = D3DDECLUSAGE_TEXCOORD;
3645 d3delements[idx].UsageIndex = 1;
3646 idx++;
3647 }
3648
3649 for (i = 0; i < ALLEGRO_PRIM_MAX_USER_ATTR; i++) {
3650 e = &decl->elements[ALLEGRO_PRIM_USER_ATTR + i];
3651 if (e->attribute) {
3652 d3delements[idx].Stream = 0;
3653 d3delements[idx].Offset = e->offset;
3654 d3delements[idx].Type = convert_storage(e->storage);
3655 d3delements[idx].Method = D3DDECLMETHOD_DEFAULT;
3656 d3delements[idx].Usage = D3DDECLUSAGE_TEXCOORD;
3657 d3delements[idx].UsageIndex = 2 + i;
3658 idx++;
3659 }
3660 }
3661
3662 d3delements[idx].Stream = 0xFF;
3663 d3delements[idx].Offset = 0;
3664 d3delements[idx].Type = D3DDECLTYPE_UNUSED;
3665 d3delements[idx].Method = 0;
3666 d3delements[idx].Usage = 0;
3667 d3delements[idx].UsageIndex = 0;
3668
3669 device->CreateVertexDeclaration(d3delements, (IDirect3DVertexDeclaration9**)&decl->d3d_decl);
3670 }
3671 return true;
3672 }
3673
3674 static bool d3d_create_vertex_buffer(ALLEGRO_VERTEX_BUFFER* buf, const void* initial_data, size_t num_vertices, int flags)
3675 {
3676 LPDIRECT3DDEVICE9 device;
3677 IDirect3DVertexBuffer9* d3d_vbuff;
3678 int stride = buf->decl ? buf->decl->stride : (int)sizeof(ALLEGRO_VERTEX);
3679 int fvf = D3DFVF_ALLEGRO_VERTEX;
3680 HRESULT res;
3681 void* locked_memory;
3682
3683 /* There's just no point */
3684 if (use_fixed_pipeline) {
3685 ALLEGRO_WARN("Cannot create vertex buffer for a legacy card.\n");
3686 return false;
3687 }
3688
3689 device = al_get_d3d_device(al_get_current_display());
3690
3691 if (buf->decl) {
3692 device->SetVertexDeclaration((IDirect3DVertexDeclaration9*)buf->decl->d3d_decl);
3693 fvf = 0;
3694 }
3695
3696 res = device->CreateVertexBuffer(stride * num_vertices, !(flags & ALLEGRO_PRIM_BUFFER_READWRITE) ? D3DUSAGE_WRITEONLY : 0,
3697 fvf, D3DPOOL_MANAGED, &d3d_vbuff, 0);
3698 if (res != D3D_OK) {
3699 ALLEGRO_WARN("CreateVertexBuffer failed: %ld.\n", res);
3700 return false;
3701 }
3702
3703 if (initial_data != NULL) {
3704 d3d_vbuff->Lock(0, 0, &locked_memory, 0);
3705 memcpy(locked_memory, initial_data, stride * num_vertices);
3706 d3d_vbuff->Unlock();
3707 }
3708
3709 buf->common.handle = (uintptr_t)d3d_vbuff;
3710
3711 return true;
3712 }
3713
3714 static bool d3d_create_index_buffer(ALLEGRO_INDEX_BUFFER* buf, const void* initial_data, size_t num_indices, int flags)
3715 {
3716 LPDIRECT3DDEVICE9 device;
3717 IDirect3DIndexBuffer9* d3d_ibuff;
3718 HRESULT res;
3719 void* locked_memory;
3720
3721 /* There's just no point */
3722 if (use_fixed_pipeline) {
3723 ALLEGRO_WARN("Cannot create index buffer for a legacy card.\n");
3724 return false;
3725 }
3726
3727 device = al_get_d3d_device(al_get_current_display());
3728
3729 res = device->CreateIndexBuffer(num_indices * buf->index_size, !(flags & ALLEGRO_PRIM_BUFFER_READWRITE) ? D3DUSAGE_WRITEONLY : 0,
3730 buf->index_size == 4 ? D3DFMT_INDEX32 : D3DFMT_INDEX16, D3DPOOL_MANAGED, &d3d_ibuff, 0);
3731 if (res != D3D_OK) {
3732 ALLEGRO_WARN("CreateIndexBuffer failed: %ld.\n", res);
3733 return false;
3734 }
3735
3736 if (initial_data != NULL) {
3737 d3d_ibuff->Lock(0, 0, &locked_memory, 0);
3738 memcpy(locked_memory, initial_data, num_indices * buf->index_size);
3739 d3d_ibuff->Unlock();
3740 }
3741
3742 buf->common.handle = (uintptr_t)d3d_ibuff;
3743
3744 return true;
3745 }
3746
3747 static void d3d_destroy_vertex_buffer(ALLEGRO_VERTEX_BUFFER* buf)
3748 {
3749 ((IDirect3DVertexBuffer9*)buf->common.handle)->Release();
3750 }
3751
3752 static void d3d_destroy_index_buffer(ALLEGRO_INDEX_BUFFER* buf)
3753 {
3754 ((IDirect3DIndexBuffer9*)buf->common.handle)->Release();
3755 }
3756
3757 static void* d3d_lock_vertex_buffer(ALLEGRO_VERTEX_BUFFER* buf)
3758 {
3759 DWORD flags = buf->common.lock_flags == ALLEGRO_LOCK_READONLY ? D3DLOCK_READONLY : 0;
3760 HRESULT res;
3761
3762 res = ((IDirect3DVertexBuffer9*)buf->common.handle)->Lock((UINT)buf->common.lock_offset, (UINT)buf->common.lock_length, &buf->common.locked_memory, flags);
3763 if (res != D3D_OK) {
3764 ALLEGRO_WARN("Locking vertex buffer failed: %ld.\n", res);
3765 return 0;
3766 }
3767
3768 return buf->common.locked_memory;
3769 }
3770
3771 static void* d3d_lock_index_buffer(ALLEGRO_INDEX_BUFFER* buf)
3772 {
3773 DWORD flags = buf->common.lock_flags == ALLEGRO_LOCK_READONLY ? D3DLOCK_READONLY : 0;
3774 HRESULT res;
3775
3776 res = ((IDirect3DIndexBuffer9*)buf->common.handle)->Lock((UINT)buf->common.lock_offset, (UINT)buf->common.lock_length, &buf->common.locked_memory, flags);
3777
3778 if (res != D3D_OK) {
3779 ALLEGRO_WARN("Locking index buffer failed: %ld.\n", res);
3780 return 0;
3781 }
3782
3783 return buf->common.locked_memory;
3784 }
3785
3786 static void d3d_unlock_vertex_buffer(ALLEGRO_VERTEX_BUFFER* buf)
3787 {
3788 ((IDirect3DVertexBuffer9*)buf->common.handle)->Unlock();
3789 }
3790
3791 static void d3d_unlock_index_buffer(ALLEGRO_INDEX_BUFFER* buf)
3792 {
3793 ((IDirect3DIndexBuffer9*)buf->common.handle)->Unlock();
3794 }
3795
3796 /* Initialize and obtain a reference to this driver. */
3797 ALLEGRO_DISPLAY_INTERFACE *_al_display_d3d_driver(void)
3798 {
3799 if (vt)
3800 return vt;
3801
3802 if (!d3d_init_display())
3803 return NULL;
3804
3805 vt = (ALLEGRO_DISPLAY_INTERFACE *)al_malloc(sizeof *vt);
3806 memset(vt, 0, sizeof *vt);
3807
3808 vt->create_display = d3d_create_display;
3809 vt->destroy_display = d3d_destroy_display;
3810 vt->set_current_display = d3d_set_current_display;
3811 vt->clear = d3d_clear;
3812 vt->clear_depth_buffer = d3d_clear_depth_buffer;
3813 vt->draw_pixel = d3d_draw_pixel;
3814 vt->flip_display = d3d_flip_display;
3815 vt->update_display_region = d3d_update_display_region;
3816 vt->acknowledge_resize = d3d_acknowledge_resize;
3817 vt->resize_display = d3d_resize_display;
3818 vt->create_bitmap = d3d_create_bitmap;
3819 vt->set_target_bitmap = d3d_set_target_bitmap;
3820 vt->get_backbuffer = d3d_get_backbuffer;
3821 vt->is_compatible_bitmap = d3d_is_compatible_bitmap;
3822 vt->switch_out = d3d_switch_out;
3823 vt->switch_in = d3d_switch_in;
3824 vt->draw_memory_bitmap_region = NULL;
3825 vt->wait_for_vsync = d3d_wait_for_vsync;
3826
3827 vt->set_mouse_cursor = _al_win_set_mouse_cursor;
3828 vt->set_system_mouse_cursor = _al_win_set_system_mouse_cursor;
3829 vt->show_mouse_cursor = _al_win_show_mouse_cursor;
3830 vt->hide_mouse_cursor = _al_win_hide_mouse_cursor;
3831
3832 vt->set_icons = _al_win_set_display_icons;
3833 vt->set_window_position = d3d_set_window_position;
3834 vt->get_window_position = d3d_get_window_position;
3835 vt->get_window_borders = _al_win_get_window_borders;
3836 vt->set_window_constraints = _al_win_set_window_constraints;
3837 vt->get_window_constraints = _al_win_get_window_constraints;
3838 vt->apply_window_constraints = _al_win_apply_window_constraints;
3839 vt->set_display_flag = _al_win_set_display_flag;
3840 vt->set_window_title = _al_win_set_window_title;
3841
3842 vt->flush_vertex_cache = d3d_flush_vertex_cache;
3843 vt->prepare_vertex_cache = d3d_prepare_vertex_cache;
3844
3845 vt->update_transformation = d3d_update_transformation;
3846
3847 vt->update_render_state = _al_d3d_update_render_state;
3848
3849 vt->draw_prim = d3d_draw_prim;
3850 vt->draw_prim_indexed = d3d_draw_prim_indexed;
3851
3852 vt->create_vertex_decl = d3d_create_vertex_decl;
3853
3854 vt->create_vertex_buffer = d3d_create_vertex_buffer;
3855 vt->destroy_vertex_buffer = d3d_destroy_vertex_buffer;
3856 vt->lock_vertex_buffer = d3d_lock_vertex_buffer;
3857 vt->unlock_vertex_buffer = d3d_unlock_vertex_buffer;
3858
3859 vt->create_index_buffer = d3d_create_index_buffer;
3860 vt->destroy_index_buffer = d3d_destroy_index_buffer;
3861 vt->lock_index_buffer = d3d_lock_index_buffer;
3862 vt->unlock_index_buffer = d3d_unlock_index_buffer;
3863
3864 vt->draw_vertex_buffer = d3d_draw_vertex_buffer;
3865 vt->draw_indexed_buffer = d3d_draw_indexed_buffer;
3866
3867 _al_win_add_clipboard_functions(vt);
3868
3869 return vt;
3870 }
3871
3872 int _al_d3d_get_num_display_modes(int format, int refresh_rate, int flags)
3873 {
3874 UINT num_modes;
3875 UINT i, j;
3876 D3DDISPLAYMODE display_mode;
3877 int matches = 0;
3878
3879 if (!_al_d3d && !d3d_init_display())
3880 return 0;
3881
3882 (void)flags;
3883
3884 /* If any, go through all formats */
3885 if (!_al_pixel_format_is_real(format)) {
3886 j = 0;
3887 }
3888 /* Else find the matching format */
3889 else {
3890 for (j = 0; allegro_formats[j] != -1; j++) {
3891 if (allegro_formats[j] == format)
3892 break;
3893 }
3894 if (allegro_formats[j] == -1)
3895 return 0;
3896 }
3897
3898 for (; allegro_formats[j] != -1; j++) {
3899 int adapter = al_get_new_display_adapter();
3900 if (adapter < 0)
3901 adapter = 0;
3902
3903 if (!_al_pixel_format_is_real(allegro_formats[j]) || _al_pixel_format_has_alpha(allegro_formats[j]))
3904 continue;
3905
3906 num_modes = _al_d3d->GetAdapterModeCount(adapter, (D3DFORMAT)d3d_formats[j]);
3907
3908 for (i = 0; i < num_modes; i++) {
3909 if (_al_d3d->EnumAdapterModes(adapter, (D3DFORMAT)d3d_formats[j], i, &display_mode) != D3D_OK) {
3910 return matches;
3911 }
3912 if (refresh_rate && display_mode.RefreshRate != (unsigned)refresh_rate)
3913 continue;
3914 matches++;
3915 }
3916
3917 if (_al_pixel_format_is_real(format))
3918 break;
3919 }
3920
3921 return matches;
3922 }
3923
3924 ALLEGRO_DISPLAY_MODE *_al_d3d_get_display_mode(int index, int format,
3925 int refresh_rate, int flags, ALLEGRO_DISPLAY_MODE *mode)
3926 {
3927 UINT num_modes;
3928 UINT i, j;
3929 D3DDISPLAYMODE display_mode;
3930 int matches = 0;
3931
3932 if (!_al_d3d && !d3d_init_display())
3933 return NULL;
3934
3935 (void)flags;
3936
3937 /* If any, go through all formats */
3938 if (!_al_pixel_format_is_real(format)) {
3939 j = 0;
3940 }
3941 /* Else find the matching format */
3942 else {
3943 for (j = 0; allegro_formats[j] != -1; j++) {
3944 if (allegro_formats[j] == format)
3945 break;
3946 }
3947 if (allegro_formats[j] == -1)
3948 return NULL;
3949 }
3950
3951 for (; allegro_formats[j] != -1; j++) {
3952 int adapter = al_get_new_display_adapter();
3953 if (adapter < 0)
3954 adapter = 0;
3955
3956 if (!_al_pixel_format_is_real(allegro_formats[j]) || _al_pixel_format_has_alpha(allegro_formats[j]))
3957 continue;
3958
3959 num_modes = _al_d3d->GetAdapterModeCount(adapter, (D3DFORMAT)d3d_formats[j]);
3960
3961 for (i = 0; i < num_modes; i++) {
3962 if (_al_d3d->EnumAdapterModes(adapter, (D3DFORMAT)d3d_formats[j], i, &display_mode) != D3D_OK) {
3963 return NULL;
3964 }
3965 if (refresh_rate && display_mode.RefreshRate != (unsigned)refresh_rate)
3966 continue;
3967 if (matches == index) {
3968 mode->width = display_mode.Width;
3969 mode->height = display_mode.Height;
3970 mode->format = allegro_formats[j];
3971 mode->refresh_rate = display_mode.RefreshRate;
3972 return mode;
3973 }
3974 matches++;
3975 }
3976
3977 if (_al_pixel_format_is_real(format))
3978 break;
3979 }
3980
3981 return mode;
3982 }
3983
3984 /* vim: set sts=3 sw=3 et: */