From 8898ad9b25fca6afe2374d293a981db02a83d7e9 Mon Sep 17 00:00:00 2001 From: "FWoltermann@gmail.com" Date: Thu, 31 May 2012 14:46:27 +0000 Subject: Committing the documentation to svn to have it accessible online --- Doc/doxygen/html/_video_d_x9_enum_8cpp_source.html | 1182 ++++++++++++++++++++ 1 file changed, 1182 insertions(+) create mode 100644 Doc/doxygen/html/_video_d_x9_enum_8cpp_source.html (limited to 'Doc/doxygen/html/_video_d_x9_enum_8cpp_source.html') diff --git a/Doc/doxygen/html/_video_d_x9_enum_8cpp_source.html b/Doc/doxygen/html/_video_d_x9_enum_8cpp_source.html new file mode 100644 index 0000000..2cf64ab --- /dev/null +++ b/Doc/doxygen/html/_video_d_x9_enum_8cpp_source.html @@ -0,0 +1,1182 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/nGenEx/VideoDX9Enum.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
VideoDX9Enum.cpp
+
+
+Go to the documentation of this file.
1 /* Project nGenEx
+
2  Destroyer Studios LLC
+
3  Copyright © 1997-2004. All Rights Reserved.
+
4 
+
5  SUBSYSTEM: nGenEx.lib
+
6  FILE: VideoDX9Enum.cpp
+
7  AUTHOR: John DiCamillo
+
8 
+
9 
+
10  OVERVIEW
+
11  ========
+
12  Direct3D Video class for DirectX 9
+
13 */
+
14 
+
15 #include "MemDebug.h"
+
16 #include "VideoDX9Enum.h"
+
17 #include "VideoSettings.h"
+
18 #include "Color.h"
+
19 
+
20 // +--------------------------------------------------------------------+
+
21 
+
22 void Print(const char* msg, ...);
+
23 char* DDErrStr(HRESULT dderr);
+
24 void VideoDX9Error(const char* msg, HRESULT dderr);
+
25 int VD3D_describe_things;
+
26 
+
27 #ifndef RELEASE
+
28 #define RELEASE(x) if (x) { x->Release(); x=NULL; }
+
29 #endif
+
30 
+
31 
+
32 // +--------------------------------------------------------------------+
+
33 
+
34 static UINT GetBitsPerPixel(D3DFORMAT fmt)
+
35 {
+
36  switch (fmt) {
+
37  case D3DFMT_A8R8G8B8: return 32;
+
38  case D3DFMT_X8R8G8B8: return 32;
+
39  case D3DFMT_A2B10G10R10: return 32;
+
40  case D3DFMT_A2R10G10B10: return 32;
+
41  case D3DFMT_R8G8B8: return 24;
+
42  case D3DFMT_R5G6B5: return 16;
+
43  case D3DFMT_X1R5G5B5: return 16;
+
44  case D3DFMT_A1R5G5B5: return 16;
+
45  case D3DFMT_A4R4G4B4: return 16;
+
46  case D3DFMT_A8R3G3B2: return 16;
+
47  case D3DFMT_X4R4G4B4: return 16;
+
48  case D3DFMT_R3G3B2: return 8;
+
49  default: return 0;
+
50  }
+
51 }
+
52 
+
53 // +--------------------------------------------------------------------+
+
54 
+
55 static UINT GetColorChannelBits(D3DFORMAT fmt)
+
56 {
+
57  switch (fmt) {
+
58  case D3DFMT_A2B10G10R10: return 10;
+
59  case D3DFMT_A2R10G10B10: return 10;
+
60  case D3DFMT_R8G8B8: return 8;
+
61  case D3DFMT_A8R8G8B8: return 8;
+
62  case D3DFMT_X8R8G8B8: return 8;
+
63  case D3DFMT_R5G6B5: return 6;
+
64  case D3DFMT_X1R5G5B5: return 5;
+
65  case D3DFMT_A1R5G5B5: return 5;
+
66  case D3DFMT_A4R4G4B4: return 4;
+
67  case D3DFMT_R3G3B2: return 2;
+
68  case D3DFMT_A8R3G3B2: return 2;
+
69  case D3DFMT_X4R4G4B4: return 4;
+
70  default: return 0;
+
71  }
+
72 }
+
73 
+
74 // +--------------------------------------------------------------------+
+
75 
+
76 static UINT GetAlphaChannelBits(D3DFORMAT fmt)
+
77 {
+
78  switch (fmt) {
+
79  case D3DFMT_R8G8B8: return 0;
+
80  case D3DFMT_A8R8G8B8: return 8;
+
81  case D3DFMT_X8R8G8B8: return 0;
+
82  case D3DFMT_R5G6B5: return 0;
+
83  case D3DFMT_X1R5G5B5: return 0;
+
84  case D3DFMT_A1R5G5B5: return 1;
+
85  case D3DFMT_A4R4G4B4: return 4;
+
86  case D3DFMT_R3G3B2: return 0;
+
87  case D3DFMT_A8R3G3B2: return 8;
+
88  case D3DFMT_X4R4G4B4: return 0;
+
89  case D3DFMT_A2B10G10R10: return 2;
+
90  case D3DFMT_A2R10G10B10: return 2;
+
91  default: return 0;
+
92  }
+
93 }
+
94 
+
95 // +--------------------------------------------------------------------+
+
96 
+
97 static UINT GetDepthBits(D3DFORMAT fmt)
+
98 {
+
99  switch (fmt) {
+
100  case D3DFMT_D16: return 16;
+
101  case D3DFMT_D15S1: return 15;
+
102  case D3DFMT_D24X8: return 24;
+
103  case D3DFMT_D24S8: return 24;
+
104  case D3DFMT_D24X4S4: return 24;
+
105  case D3DFMT_D32: return 32;
+
106  default: return 0;
+
107  }
+
108 }
+
109 
+
110 // +--------------------------------------------------------------------+
+
111 
+
112 static UINT GetStencilBits(D3DFORMAT fmt)
+
113 {
+
114  switch (fmt) {
+
115  case D3DFMT_D16: return 0;
+
116  case D3DFMT_D15S1: return 1;
+
117  case D3DFMT_D24X8: return 0;
+
118  case D3DFMT_D24S8: return 8;
+
119  case D3DFMT_D24X4S4: return 4;
+
120  case D3DFMT_D32: return 0;
+
121  default: return 0;
+
122  }
+
123 }
+
124 
+
125 // +--------------------------------------------------------------------+
+
126 //
+
127 // This routine prints a text description of the indicated driver
+
128 // into the error log file.
+
129 
+
130 static void DescribeGUID(GUID* lpGUID)
+
131 {
+
132  if (lpGUID)
+
133  Print(" GUID: %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
+
134  lpGUID->Data1, lpGUID->Data2, lpGUID->Data3,
+
135  lpGUID->Data4[0], lpGUID->Data4[1],
+
136  lpGUID->Data4[2], lpGUID->Data4[3],
+
137  lpGUID->Data4[4], lpGUID->Data4[5],
+
138  lpGUID->Data4[6], lpGUID->Data4[7]);
+
139  else
+
140  Print(" GUID IS NULL!\n");
+
141 }
+
142 
+
143 
+
144 // +--------------------------------------------------------------------+
+
145 
+
146 VideoDX9Enum::VideoDX9Enum(IDirect3D9* d3d9)
+
147 {
+
148  if (d3d9) {
+
149  d3d = d3d9;
+
150  d3d->AddRef();
+
151  }
+
152 
+
153  min_width = 640;
+
154  min_height = 480;
+
155  min_color_bits = 5;
+
156  min_alpha_bits = 0;
+
157  min_depth_bits = 16;
+
158  min_stencil_bits = 0;
+
159 
+
160  uses_depth_buffer = false;
+
161  uses_mixed_vp = false;
+
162  req_windowed = false;
+
163  req_fullscreen = false;
+
164 
+
165  adapter_index = 0;
+
166 }
+
167 
+
168 VideoDX9Enum::~VideoDX9Enum()
+
169 {
+
170  adapter_info_list.destroy();
+
171  RELEASE(d3d);
+
172 }
+
173 
+
174 void
+
175 VideoDX9Enum::SetDirect3D9(IDirect3D9* d3d9)
+
176 {
+
177  RELEASE(d3d);
+
178 
+
179  if (d3d9) {
+
180  d3d = d3d9;
+
181  d3d->AddRef();
+
182  }
+
183 }
+
184 
+
185 
+
186 // +--------------------------------------------------------------------+
+
187 
+
188 void
+
189 VideoDX9Enum::SelectAdapter(int index)
+
190 {
+
191  if (index >= 0 && index < adapter_info_list.size())
+
192  adapter_index = index;
+
193 }
+
194 
+
195 VideoDX9AdapterInfo*
+
196 VideoDX9Enum::GetAdapterInfo()
+
197 {
+
198  if (adapter_index >= 0 && adapter_index < adapter_info_list.size())
+
199  return adapter_info_list[adapter_index];
+
200 
+
201  return 0;
+
202 }
+
203 
+
204 VideoDX9DeviceInfo*
+
205 VideoDX9Enum::GetDeviceInfo(DWORD devtype)
+
206 {
+
207  if (adapter_index >= 0 && adapter_index < adapter_info_list.size()) {
+
208  VideoDX9AdapterInfo* adapter = adapter_info_list[adapter_index];
+
209 
+
210  if (adapter) {
+
211  ListIter<VideoDX9DeviceInfo> iter = adapter->device_info_list;
+
212  while (++iter) {
+
213  VideoDX9DeviceInfo* dev_info = iter.value();
+
214 
+
215  if (dev_info->device_type == (D3DDEVTYPE) devtype)
+
216  return dev_info;
+
217  }
+
218  }
+
219  }
+
220 
+
221  return 0;
+
222 }
+
223 
+
224 bool
+
225 VideoDX9Enum::IsModeSupported(int w, int h, int b) const
+
226 {
+
227  if (adapter_index >= 0 && adapter_index < adapter_info_list.size()) {
+
228  VideoDX9AdapterInfo* adapter = adapter_info_list[adapter_index];
+
229 
+
230  ListIter<VideoDX9DisplayMode> mode_iter = adapter->display_mode_list;
+
231  while (++mode_iter) {
+
232  VideoDX9DisplayMode* mode = mode_iter.value();
+
233 
+
234  if (mode->width == (UINT) w &&
+
235  mode->height == (UINT) h &&
+
236  GetBitsPerPixel(mode->format) == (UINT) b) {
+
237 
+
238  return true;
+
239  }
+
240  }
+
241  }
+
242 
+
243  return false;
+
244 }
+
245 
+
246 // +--------------------------------------------------------------------+
+
247 
+
248 HRESULT
+
249 VideoDX9Enum::Enumerate()
+
250 {
+
251  HRESULT hr = E_FAIL;
+
252 
+
253  if (!d3d)
+
254  return hr;
+
255 
+
256  if (VD3D_describe_things > 0) {
+
257  Print("Video DX9 Enumerate Adapters and Devices\n");
+
258  Print("----------------------------------------\n\n");
+
259  }
+
260 
+
261  allowed_adapter_format_list.push_back(D3DFMT_X8R8G8B8);
+
262  allowed_adapter_format_list.push_back(D3DFMT_X1R5G5B5);
+
263  allowed_adapter_format_list.push_back(D3DFMT_R5G6B5);
+
264  allowed_adapter_format_list.push_back(D3DFMT_A2R10G10B10);
+
265 
+
266  VideoDX9AdapterInfo* adapter_info = 0;
+
267  std::vector<D3DFORMAT> adapter_format_list;
+
268  UINT num_adapters = d3d->GetAdapterCount();
+
269 
+
270  for (UINT ordinal = 0; ordinal < num_adapters; ordinal++) {
+
271  adapter_info = new(__FILE__,__LINE__) VideoDX9AdapterInfo;
+
272  if (!adapter_info)
+
273  return E_OUTOFMEMORY;
+
274 
+
275  adapter_info->adapter_ordinal = ordinal;
+
276  d3d->GetAdapterIdentifier(ordinal, 0, &adapter_info->adapter_identifier);
+
277 
+
278  // Get list of all display modes on this adapter.
+
279  // Also build a temporary list of all display adapter formats.
+
280  adapter_format_list.clear();
+
281 
+
282  for (size_t iaaf = 0; iaaf < allowed_adapter_format_list.size(); iaaf++) {
+
283  D3DFORMAT allowed_adapter_format = allowed_adapter_format_list[iaaf];
+
284  UINT num_adapter_modes = d3d->GetAdapterModeCount(ordinal, allowed_adapter_format);
+
285 
+
286  for (UINT mode = 0; mode < num_adapter_modes; mode++) {
+
287  D3DDISPLAYMODE display_mode;
+
288  d3d->EnumAdapterModes(ordinal, allowed_adapter_format, mode, &display_mode);
+
289 
+
290  if (display_mode.Width < min_width ||
+
291  display_mode.Height < min_height ||
+
292  GetColorChannelBits(display_mode.Format) < min_color_bits) {
+
293  continue;
+
294  }
+
295 
+
296  VideoDX9DisplayMode* dx9_display_mode = new(__FILE__,__LINE__) VideoDX9DisplayMode(display_mode);
+
297 
+
298  if (!dx9_display_mode) {
+
299  delete adapter_info;
+
300  return E_OUTOFMEMORY;
+
301  }
+
302 
+
303  adapter_info->display_mode_list.append(dx9_display_mode);
+
304 
+
305  bool contains_display_mode = false;
+
306  for (auto afli = adapter_format_list.begin(); afli != adapter_format_list.end(); ++afli) {
+
307  if (*afli == display_mode.Format) {
+
308  contains_display_mode = true;
+
309  break;
+
310  }
+
311  }
+
312  if (!contains_display_mode)
+
313  adapter_format_list.push_back(display_mode.Format);
+
314 
+
315  }
+
316  }
+
317 
+
318  // Sort displaymode list
+
319  adapter_info->display_mode_list.sort();
+
320 
+
321  if (VD3D_describe_things > 0) {
+
322  Print("Adapter %d. %s\n", ordinal, adapter_info->adapter_identifier.Description);
+
323  DescribeGUID(&adapter_info->adapter_identifier.DeviceIdentifier);
+
324 
+
325  if (VD3D_describe_things > 4) {
+
326  ListIter<VideoDX9DisplayMode> m_iter = adapter_info->display_mode_list;
+
327  while (++m_iter) {
+
328  VideoDX9DisplayMode* m = m_iter.value();
+
329 
+
330  Print(" Mode %3d %s\n", m_iter.index(), m->GetDescription());
+
331  }
+
332 
+
333  Print("\n");
+
334  }
+
335  }
+
336 
+
337  // Get info for each device on this adapter
+
338  if (FAILED(hr = EnumerateDevices(adapter_info, adapter_format_list))) {
+
339  delete adapter_info;
+
340  return hr;
+
341  }
+
342 
+
343  // If at least one device on this adapter is available and compatible
+
344  // with the app, add the adapterInfo to the list
+
345  if (adapter_info->device_info_list.size() == 0)
+
346  delete adapter_info;
+
347  else
+
348  adapter_info_list.append(adapter_info);
+
349 
+
350  if (VD3D_describe_things > 0) {
+
351  Print("\n");
+
352  }
+
353  }
+
354 
+
355  return S_OK;
+
356 }
+
357 
+
358 // +--------------------------------------------------------------------+
+
359 
+
360 HRESULT
+
361 VideoDX9Enum::EnumerateDevices(VideoDX9AdapterInfo* adapter_info, std::vector<D3DFORMAT>& adapter_format_list)
+
362 {
+
363  HRESULT hr = E_FAIL;
+
364  const D3DDEVTYPE dtypes[3] = { D3DDEVTYPE_HAL, D3DDEVTYPE_SW, D3DDEVTYPE_REF };
+
365  const char* dtypestr[3] = { "D3DDEVTYPE_HAL", "D3DDEVTYPE_SW", "D3DDEVTYPE_REF" };
+
366  VideoDX9DeviceInfo* device_info = 0;
+
367 
+
368  for (int i = 0; i < 3; i++ ) {
+
369  device_info = new(__FILE__,__LINE__) VideoDX9DeviceInfo;
+
370  if (!device_info)
+
371  return E_OUTOFMEMORY;
+
372 
+
373  device_info->adapter_ordinal = adapter_info->adapter_ordinal;
+
374  device_info->device_type = dtypes[i];
+
375 
+
376  if (FAILED(d3d->GetDeviceCaps(adapter_info->adapter_ordinal,
+
377  device_info->device_type,
+
378  &device_info->caps))) {
+
379  delete device_info;
+
380  continue;
+
381  }
+
382 
+
383  if (VD3D_describe_things > 1) {
+
384  Print(" Device %d - %s\n", i, dtypestr[i]);
+
385  Print(" Max Texture Width: %d\n", device_info->caps.MaxTextureWidth);
+
386  Print(" Max Texture Height: %d\n", device_info->caps.MaxTextureHeight);
+
387  }
+
388 
+
389  // Get info for each device combo on this device
+
390  if (FAILED(hr = EnumerateDeviceCombos(device_info, adapter_format_list))) {
+
391  delete device_info;
+
392  return hr;
+
393  }
+
394 
+
395  // make sure at least one devicecombo for this device was found
+
396  if (device_info->device_combo_list.size() < 1) {
+
397  delete device_info;
+
398  continue;
+
399  }
+
400 
+
401  adapter_info->device_info_list.append(device_info);
+
402  }
+
403 
+
404  return S_OK;
+
405 }
+
406 
+
407 // +--------------------------------------------------------------------+
+
408 
+
409 HRESULT
+
410 VideoDX9Enum::EnumerateDeviceCombos(VideoDX9DeviceInfo* device_info, std::vector<D3DFORMAT>& adapter_format_list)
+
411 {
+
412  const D3DFORMAT back_buffer_formats[] = {
+
413  D3DFMT_A8R8G8B8,
+
414  D3DFMT_X8R8G8B8,
+
415  D3DFMT_R8G8B8,
+
416  D3DFMT_R5G6B5,
+
417  D3DFMT_A1R5G5B5,
+
418  D3DFMT_X1R5G5B5
+
419  };
+
420 
+
421  bool is_windowed[] = { false, true };
+
422 
+
423  // See which adapter formats are supported by this device
+
424  D3DFORMAT a_fmt;
+
425  for (size_t i = 0; i < adapter_format_list.size(); i++) {
+
426  a_fmt = adapter_format_list[i];
+
427 
+
428  D3DFORMAT b_fmt;
+
429  for (int n = 0; n < 6; n++) {
+
430  b_fmt = back_buffer_formats[n];
+
431 
+
432  if (GetAlphaChannelBits(b_fmt) < min_alpha_bits)
+
433  continue;
+
434 
+
435  bool win;
+
436  for (int w = 0; w < 2; w++) {
+
437  win = is_windowed[w];
+
438 
+
439  if (!win && req_windowed)
+
440  continue;
+
441 
+
442  if (win && req_fullscreen)
+
443  continue;
+
444 
+
445  if (FAILED(d3d->CheckDeviceType(device_info->adapter_ordinal,
+
446  device_info->device_type,
+
447  a_fmt,
+
448  b_fmt,
+
449  win))) {
+
450  continue;
+
451  }
+
452 
+
453  // At this point, we have an adapter/device/adapterformat/backbufferformat/iswindowed
+
454  // DeviceCombo that is supported by the system. We still need to confirm that it's
+
455  // compatible with the app, and find one or more suitable depth/stencil buffer format,
+
456  // multisample type, vertex processing type, and present interval.
+
457 
+
458  VideoDX9DeviceCombo* device_combo = 0;
+
459  device_combo = new(__FILE__,__LINE__) VideoDX9DeviceCombo;
+
460  if (!device_combo)
+
461  return E_OUTOFMEMORY;
+
462 
+
463  device_combo->adapter_ordinal = device_info->adapter_ordinal;
+
464  device_combo->device_type = device_info->device_type;
+
465  device_combo->adapter_format = a_fmt;
+
466  device_combo->back_buffer_format = b_fmt;
+
467  device_combo->is_windowed = win;
+
468 
+
469  if (uses_depth_buffer) {
+
470  BuildDepthStencilFormatList(device_combo);
+
471  if (device_combo->depth_stencil_fmt_list.size() < 1) {
+
472  delete device_combo;
+
473  continue;
+
474  }
+
475  }
+
476 
+
477  BuildMultiSampleTypeList(device_combo);
+
478  if (device_combo->multisample_type_list.size() < 1) {
+
479  delete device_combo;
+
480  continue;
+
481  }
+
482 
+
483  BuildDSMSConflictList(device_combo);
+
484 
+
485  BuildVertexProcessingTypeList(device_info, device_combo);
+
486  if (device_combo->vertex_processing_list.size() < 1) {
+
487  delete device_combo;
+
488  continue;
+
489  }
+
490 
+
491  BuildPresentIntervalList(device_info, device_combo);
+
492 
+
493  device_info->device_combo_list.append(device_combo);
+
494  }
+
495  }
+
496  }
+
497 
+
498  return S_OK;
+
499 }
+
500 
+
501 void
+
502 VideoDX9Enum::BuildDepthStencilFormatList(VideoDX9DeviceCombo* device_combo)
+
503 {
+
504  const D3DFORMAT depth_stencil_formats[] = {
+
505  D3DFMT_D32,
+
506  D3DFMT_D24S8,
+
507  D3DFMT_D24X4S4,
+
508  D3DFMT_D24X8,
+
509  D3DFMT_D16,
+
510  D3DFMT_D15S1,
+
511  };
+
512 
+
513  for (int i = 0; i < 6; i++) {
+
514  D3DFORMAT fmt = depth_stencil_formats[i];
+
515 
+
516  if (GetDepthBits(fmt) < min_depth_bits)
+
517  continue;
+
518 
+
519  if (GetStencilBits(fmt) < min_stencil_bits)
+
520  continue;
+
521 
+
522  if (SUCCEEDED(d3d->CheckDeviceFormat(device_combo->adapter_ordinal,
+
523  device_combo->device_type,
+
524  device_combo->adapter_format,
+
525  D3DUSAGE_DEPTHSTENCIL,
+
526  D3DRTYPE_SURFACE,
+
527  fmt))) {
+
528 
+
529  if (SUCCEEDED(d3d->CheckDepthStencilMatch(device_combo->adapter_ordinal,
+
530  device_combo->device_type,
+
531  device_combo->adapter_format,
+
532  device_combo->back_buffer_format,
+
533  fmt))) {
+
534 
+
535  device_combo->depth_stencil_fmt_list.push_back(fmt);
+
536  }
+
537  }
+
538  }
+
539 }
+
540 
+
541 void
+
542 VideoDX9Enum::BuildMultiSampleTypeList(VideoDX9DeviceCombo* device_combo)
+
543 {
+
544  const D3DMULTISAMPLE_TYPE multisample_type_array[] = {
+
545  D3DMULTISAMPLE_NONE,
+
546  D3DMULTISAMPLE_NONMASKABLE,
+
547  D3DMULTISAMPLE_2_SAMPLES,
+
548  D3DMULTISAMPLE_3_SAMPLES,
+
549  D3DMULTISAMPLE_4_SAMPLES,
+
550  D3DMULTISAMPLE_5_SAMPLES,
+
551  D3DMULTISAMPLE_6_SAMPLES,
+
552  D3DMULTISAMPLE_7_SAMPLES,
+
553  D3DMULTISAMPLE_8_SAMPLES,
+
554  D3DMULTISAMPLE_9_SAMPLES,
+
555  D3DMULTISAMPLE_10_SAMPLES,
+
556  D3DMULTISAMPLE_11_SAMPLES,
+
557  D3DMULTISAMPLE_12_SAMPLES,
+
558  D3DMULTISAMPLE_13_SAMPLES,
+
559  D3DMULTISAMPLE_14_SAMPLES,
+
560  D3DMULTISAMPLE_15_SAMPLES,
+
561  D3DMULTISAMPLE_16_SAMPLES,
+
562  };
+
563 
+
564  for (int i = 0; i < 17; i++) {
+
565  D3DMULTISAMPLE_TYPE multisample_type = multisample_type_array[i];
+
566  DWORD multisample_qual = 0;
+
567 
+
568  if (SUCCEEDED(d3d->CheckDeviceMultiSampleType(device_combo->adapter_ordinal,
+
569  device_combo->device_type,
+
570  device_combo->back_buffer_format,
+
571  device_combo->is_windowed,
+
572  multisample_type,
+
573  &multisample_qual))) {
+
574 
+
575  device_combo->multisample_type_list.push_back(multisample_type);
+
576  device_combo->multisample_qual_list.push_back(multisample_qual);
+
577  }
+
578  }
+
579 }
+
580 
+
581 void
+
582 VideoDX9Enum::BuildDSMSConflictList(VideoDX9DeviceCombo* device_combo)
+
583 {
+
584  for (size_t i = 0; i < device_combo->depth_stencil_fmt_list.size(); i++) {
+
585  D3DFORMAT depth_format = (D3DFORMAT) device_combo->depth_stencil_fmt_list[i];
+
586 
+
587  for (size_t n = 0; n < device_combo->multisample_type_list.size(); n++) {
+
588  D3DMULTISAMPLE_TYPE multisample_type = (D3DMULTISAMPLE_TYPE) device_combo->multisample_type_list[n];
+
589 
+
590  if (FAILED(d3d->CheckDeviceMultiSampleType(device_combo->adapter_ordinal,
+
591  device_combo->device_type,
+
592  depth_format,
+
593  device_combo->is_windowed,
+
594  multisample_type,
+
595  NULL))) {
+
596 
+
597  VideoDX9FormatConflict* conflict = new(__FILE__,__LINE__) VideoDX9FormatConflict;
+
598 
+
599  conflict->ds_format = depth_format;
+
600  conflict->multisample_type = multisample_type;
+
601 
+
602  device_combo->conflict_list.append(conflict);
+
603  }
+
604  }
+
605  }
+
606 }
+
607 
+
608 void
+
609 VideoDX9Enum::BuildVertexProcessingTypeList(VideoDX9DeviceInfo* device_info, VideoDX9DeviceCombo* device_combo)
+
610 {
+
611  if ((device_info->caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0) {
+
612  if ((device_info->caps.DevCaps & D3DDEVCAPS_PUREDEVICE) != 0) {
+
613  device_combo->vertex_processing_list.push_back(PURE_HARDWARE_VP);
+
614  }
+
615 
+
616  device_combo->vertex_processing_list.push_back(HARDWARE_VP);
+
617 
+
618  if (uses_mixed_vp) {
+
619  device_combo->vertex_processing_list.push_back(MIXED_VP);
+
620  }
+
621  }
+
622 
+
623  device_combo->vertex_processing_list.push_back(SOFTWARE_VP);
+
624 }
+
625 
+
626 void
+
627 VideoDX9Enum::BuildPresentIntervalList(VideoDX9DeviceInfo* device_info, VideoDX9DeviceCombo* device_combo)
+
628 {
+
629  const DWORD present_interval_array[] = {
+
630  D3DPRESENT_INTERVAL_IMMEDIATE,
+
631  D3DPRESENT_INTERVAL_DEFAULT,
+
632  D3DPRESENT_INTERVAL_ONE,
+
633  D3DPRESENT_INTERVAL_TWO,
+
634  D3DPRESENT_INTERVAL_THREE,
+
635  D3DPRESENT_INTERVAL_FOUR,
+
636  };
+
637 
+
638  for (int i = 0; i < 6; i++) {
+
639  DWORD interval = present_interval_array[i];
+
640 
+
641  if (device_combo->is_windowed && i > 2) {
+
642  // none of the remaining intervals are supported in windowed mode.
+
643  break;
+
644  }
+
645 
+
646  // Note that D3DPRESENT_INTERVAL_DEFAULT is zero, so you
+
647  // can't do a caps check for it -- it is always available.
+
648 
+
649  if (interval == D3DPRESENT_INTERVAL_DEFAULT ||
+
650  (device_info->caps.PresentationIntervals & interval)) {
+
651 
+
652  device_combo->present_interval_list.push_back(interval);
+
653  }
+
654  }
+
655 }
+
656 
+
657 bool
+
658 VideoDX9Enum::SuggestWindowSettings(VideoSettings* vs)
+
659 {
+
660  if (!vs)
+
661  return false;
+
662 
+
663  // Get display mode of primary adapter (which is assumed to be where the window
+
664  // will appear)
+
665  D3DDISPLAYMODE desktop_display_mode;
+
666  d3d->GetAdapterDisplayMode(0, &desktop_display_mode);
+
667 
+
668  VideoDX9AdapterInfo* best_adapter_info = 0;
+
669  VideoDX9DeviceInfo* best_device_info = 0;
+
670  VideoDX9DeviceCombo* best_device_combo = 0;
+
671  int best_adapter_index = 0;
+
672  int best_device_index = 0;
+
673 
+
674  ListIter<VideoDX9AdapterInfo> a_iter = adapter_info_list;
+
675  while (++a_iter) {
+
676  VideoDX9AdapterInfo* adapter_info = a_iter.value();
+
677 
+
678  ListIter<VideoDX9DeviceInfo> d_iter = adapter_info->device_info_list;
+
679  while (++d_iter) {
+
680  VideoDX9DeviceInfo* device_info = d_iter.value();
+
681 
+
682  ListIter<VideoDX9DeviceCombo> c_iter = device_info->device_combo_list;
+
683  while (++c_iter) {
+
684  VideoDX9DeviceCombo* device_combo = c_iter.value();
+
685 
+
686  bool formats_match = (device_combo->back_buffer_format == device_combo->adapter_format);
+
687 
+
688  if (!device_combo->is_windowed)
+
689  continue;
+
690 
+
691  if (device_combo->adapter_format != desktop_display_mode.Format)
+
692  continue;
+
693 
+
694  // If we haven't found a compatible DeviceCombo yet, or if this set
+
695  // is better (because it's a HAL, and/or because formats match better),
+
696  // save it
+
697  if (best_device_combo == NULL ||
+
698  best_device_combo->device_type != D3DDEVTYPE_HAL && device_combo->device_type == D3DDEVTYPE_HAL ||
+
699  device_combo->device_type == D3DDEVTYPE_HAL && formats_match) {
+
700 
+
701  best_adapter_info = adapter_info;
+
702  best_adapter_index = a_iter.index();
+
703  best_device_info = device_info;
+
704  best_device_index = d_iter.index();
+
705  best_device_combo = device_combo;
+
706 
+
707  if (device_combo->device_type == D3DDEVTYPE_HAL && formats_match) {
+
708  // This windowed device combo looks great -- take it
+
709  goto EndWindowedDeviceComboSearch;
+
710  }
+
711 
+
712  // Otherwise keep looking for a better windowed device combo
+
713  }
+
714  }
+
715  }
+
716  }
+
717 
+
718 EndWindowedDeviceComboSearch:
+
719  if (best_device_combo == NULL)
+
720  return false;
+
721 
+
722  VideoDeviceInfo* win_device = &vs->windowed_device;
+
723 
+
724  vs->is_windowed = true;
+
725  vs->windowed_mode.width = desktop_display_mode.Width;
+
726  vs->windowed_mode.height = desktop_display_mode.Height;
+
727  vs->windowed_mode.refresh = desktop_display_mode.RefreshRate;
+
728  vs->windowed_mode.format = desktop_display_mode.Format;
+
729 
+
730  win_device->adapter_index = best_adapter_index;
+
731  win_device->device_index = best_device_index;
+
732  win_device->device_type = best_device_info->device_type;
+
733  win_device->back_buffer_format = best_device_combo->back_buffer_format;
+
734  win_device->depth_buffer_bits = GetDepthBits((D3DFORMAT) best_device_combo->depth_stencil_fmt_list[0]);
+
735  win_device->depth_stencil_format = best_device_combo->depth_stencil_fmt_list[0];
+
736  win_device->multisample_type = best_device_combo->multisample_type_list[0];
+
737  win_device->multisample_qual = best_device_combo->multisample_qual_list[0];
+
738  win_device->vertex_processing = best_device_combo->vertex_processing_list[0];
+
739 
+
740  return true;
+
741 }
+
742 
+
743 bool
+
744 VideoDX9Enum::SuggestFullscreenSettings(VideoSettings* vs)
+
745 {
+
746  if (!vs)
+
747  return false;
+
748 
+
749  WORD desired_width = vs->fullscreen_mode.width;
+
750  WORD desired_height = vs->fullscreen_mode.height;
+
751 
+
752  // For fullscreen, default to first HAL DeviceCombo that supports the current desktop
+
753  // display mode, or any display mode if HAL is not compatible with the desktop mode, or
+
754  // non-HAL if no HAL is available
+
755  D3DDISPLAYMODE desktop_display_mode;
+
756  D3DDISPLAYMODE best_desktop_display_mode;
+
757 
+
758  best_desktop_display_mode.Width = 0;
+
759  best_desktop_display_mode.Height = 0;
+
760  best_desktop_display_mode.Format = D3DFMT_UNKNOWN;
+
761  best_desktop_display_mode.RefreshRate = 0;
+
762 
+
763  VideoDX9AdapterInfo* best_adapter_info = 0;
+
764  VideoDX9DeviceInfo* best_device_info = 0;
+
765  VideoDX9DeviceCombo* best_device_combo = 0;
+
766  int best_adapter_index = 0;
+
767  int best_device_index = 0;
+
768 
+
769  ListIter<VideoDX9AdapterInfo> a_iter = adapter_info_list;
+
770  while (++a_iter) {
+
771  VideoDX9AdapterInfo* adapter_info = a_iter.value();
+
772  d3d->GetAdapterDisplayMode(adapter_info->adapter_ordinal, &desktop_display_mode);
+
773 
+
774  ListIter<VideoDX9DeviceInfo> d_iter = adapter_info->device_info_list;
+
775  while (++d_iter) {
+
776  VideoDX9DeviceInfo* device_info = d_iter.value();
+
777 
+
778  ListIter<VideoDX9DeviceCombo> c_iter = device_info->device_combo_list;
+
779  while (++c_iter) {
+
780  VideoDX9DeviceCombo* device_combo = c_iter.value();
+
781 
+
782  bool bAdapterMatchesBB = (device_combo->back_buffer_format == device_combo->adapter_format);
+
783  bool bAdapterMatchesDesktop = (device_combo->adapter_format == desktop_display_mode.Format);
+
784 
+
785  if (device_combo->is_windowed)
+
786  continue;
+
787 
+
788  // If we haven't found a compatible set yet, or if this set
+
789  // is better (because it's a HAL, and/or because formats match better),
+
790  // save it
+
791  if (best_device_combo == NULL ||
+
792  best_device_combo->device_type != D3DDEVTYPE_HAL && device_info->device_type == D3DDEVTYPE_HAL ||
+
793  device_combo->device_type == D3DDEVTYPE_HAL && best_device_combo->adapter_format != desktop_display_mode.Format && bAdapterMatchesDesktop ||
+
794  device_combo->device_type == D3DDEVTYPE_HAL && bAdapterMatchesDesktop && bAdapterMatchesBB ) {
+
795 
+
796  best_desktop_display_mode = desktop_display_mode;
+
797  best_adapter_info = adapter_info;
+
798  best_device_info = device_info;
+
799  best_device_combo = device_combo;
+
800 
+
801  if (device_info->device_type == D3DDEVTYPE_HAL && bAdapterMatchesDesktop && bAdapterMatchesBB) {
+
802  // This fullscreen device combo looks great -- take it
+
803  goto EndFullscreenDeviceComboSearch;
+
804  }
+
805 
+
806  // Otherwise keep looking for a better fullscreen device combo
+
807  }
+
808  }
+
809  }
+
810  }
+
811 
+
812 EndFullscreenDeviceComboSearch:
+
813  if (best_device_combo == NULL)
+
814  return false;
+
815 
+
816  // Need to find a display mode on the best adapter that uses best_device_combo->adapter_format
+
817  // and is as close to best_desktop_display_mode's res as possible
+
818  VideoDX9DisplayMode best_display_mode;
+
819 
+
820  ListIter<VideoDX9DisplayMode> m_iter = best_adapter_info->display_mode_list;
+
821  while (++m_iter) {
+
822  VideoDX9DisplayMode* display_mode = m_iter.value();
+
823 
+
824  if (display_mode->format != best_device_combo->adapter_format)
+
825  continue;
+
826 
+
827  if (display_mode->width == desired_width && //best_desktop_display_mode.Width &&
+
828  display_mode->height == desired_height && //best_desktop_display_mode.Height &&
+
829  display_mode->refresh == best_desktop_display_mode.RefreshRate) {
+
830 
+
831  // found a perfect match, so stop
+
832  best_display_mode = *display_mode;
+
833  break;
+
834  }
+
835  else if (display_mode->width == desired_width && //best_desktop_display_mode.Width &&
+
836  display_mode->height == desired_height && //best_desktop_display_mode.Height &&
+
837  display_mode->refresh > best_desktop_display_mode.RefreshRate) {
+
838  // refresh rate doesn't match, but width/height match, so keep this
+
839  // and keep looking
+
840  best_display_mode = *display_mode;
+
841  }
+
842  else if (display_mode->width == desired_width) { //best_desktop_display_mode.Width) {
+
843  // width matches, so keep this and keep looking
+
844  best_display_mode = *display_mode;
+
845  }
+
846  else if (best_display_mode.width == 0)
+
847  {
+
848  // we don't have anything better yet, so keep this and keep looking
+
849  best_display_mode = *display_mode;
+
850  }
+
851  }
+
852 
+
853  VideoDeviceInfo* fs_device = &vs->fullscreen_device;
+
854 
+
855  vs->is_windowed = false;
+
856  vs->fullscreen_mode.width = best_display_mode.width;
+
857  vs->fullscreen_mode.height = best_display_mode.height;
+
858  vs->fullscreen_mode.refresh = best_display_mode.refresh;
+
859  vs->fullscreen_mode.format = best_display_mode.format;
+
860 
+
861  fs_device->adapter_index = best_adapter_index;
+
862  fs_device->device_index = best_device_index;
+
863  fs_device->device_type = best_device_info->device_type;
+
864  fs_device->back_buffer_format = best_device_combo->back_buffer_format;
+
865  fs_device->depth_buffer_bits = GetDepthBits((D3DFORMAT) best_device_combo->depth_stencil_fmt_list[0]);
+
866  fs_device->depth_stencil_format = best_device_combo->depth_stencil_fmt_list[0];
+
867  fs_device->multisample_type = best_device_combo->multisample_type_list[0];
+
868  fs_device->multisample_qual = best_device_combo->multisample_qual_list[0];
+
869  fs_device->vertex_processing = best_device_combo->vertex_processing_list[0];
+
870 
+
871  return true;
+
872 }
+
873 
+
874 
+
875 // +--------------------------------------------------------------------+
+
876 // +--------------------------------------------------------------------+
+
877 // +--------------------------------------------------------------------+
+
878 
+
879 VideoDX9DisplayMode::VideoDX9DisplayMode()
+
880 : width(0), height(0), refresh(0), format(D3DFMT_UNKNOWN)
+
881 { }
+
882 
+
883 VideoDX9DisplayMode::VideoDX9DisplayMode(const VideoDX9DisplayMode& m)
+
884 : width(m.width), height(m.height), refresh(m.refresh), format(m.format)
+
885 { }
+
886 
+
887 VideoDX9DisplayMode::VideoDX9DisplayMode(const D3DDISPLAYMODE& m)
+
888 : width(m.Width), height(m.Height), refresh(m.RefreshRate), format(m.Format)
+
889 { }
+
890 
+
891 int
+
892 VideoDX9DisplayMode::operator<(const VideoDX9DisplayMode& m) const
+
893 {
+
894  if (width < m.width)
+
895  return 1;
+
896 
+
897  if (width > m.width)
+
898  return 0;
+
899 
+
900  if (height < m.height)
+
901  return 1;
+
902 
+
903  if (height > m.height)
+
904  return 0;
+
905 
+
906  if (format < m.format)
+
907  return 1;
+
908 
+
909  if (format > m.format)
+
910  return 0;
+
911 
+
912  if (refresh < m.refresh)
+
913  return 1;
+
914 
+
915  return 0;
+
916 }
+
917 
+
918 int
+
919 VideoDX9DisplayMode::operator<=(const VideoDX9DisplayMode& m) const
+
920 {
+
921  // if less than ...
+
922  if (*this < m)
+
923  return 1;
+
924 
+
925  // ... or equal to ...
+
926  if (width == m.width &&
+
927  height == m.height &&
+
928  format == m.format &&
+
929  refresh == m.refresh)
+
930  return 1;
+
931 
+
932  // must be greater than
+
933  return 0;
+
934 }
+
935 
+
936 const char*
+
937 VideoDX9DisplayMode::GetDescription() const
+
938 {
+
939  static char desc[32];
+
940 
+
941  sprintf_s(desc, "%4d x %4d %-12s %d Hz",
+
942  width,
+
943  height,
+
944  D3DFormatToString(format),
+
945  refresh);
+
946 
+
947  return desc;
+
948 }
+
949 
+
950 const char*
+
951 VideoDX9DisplayMode::D3DFormatToString(D3DFORMAT format)
+
952 {
+
953  const char* str = "Unknown Format";
+
954 
+
955  switch (format) {
+
956  case D3DFMT_UNKNOWN: str = "UNKNOWN"; break;
+
957  case D3DFMT_R8G8B8: str = "R8G8B8"; break;
+
958  case D3DFMT_A8R8G8B8: str = "A8R8G8B8"; break;
+
959  case D3DFMT_X8R8G8B8: str = "X8R8G8B8"; break;
+
960  case D3DFMT_R5G6B5: str = "R5G6B5"; break;
+
961  case D3DFMT_X1R5G5B5: str = "X1R5G5B5"; break;
+
962  case D3DFMT_A1R5G5B5: str = "A1R5G5B5"; break;
+
963  case D3DFMT_A4R4G4B4: str = "A4R4G4B4"; break;
+
964  case D3DFMT_R3G3B2: str = "R3G3B2"; break;
+
965  case D3DFMT_A8: str = "A8"; break;
+
966  case D3DFMT_A8R3G3B2: str = "A8R3G3B2"; break;
+
967  case D3DFMT_X4R4G4B4: str = "X4R4G4B4"; break;
+
968  case D3DFMT_A2B10G10R10: str = "A2B10G10R10"; break;
+
969  case D3DFMT_A8B8G8R8: str = "A8B8G8R8"; break;
+
970  case D3DFMT_X8B8G8R8: str = "X8B8G8R8"; break;
+
971  case D3DFMT_G16R16: str = "G16R16"; break;
+
972  case D3DFMT_A2R10G10B10: str = "A2R10G10B10"; break;
+
973  case D3DFMT_A16B16G16R16: str = "A16B16G16R16"; break;
+
974  case D3DFMT_A8P8: str = "A8P8"; break;
+
975  case D3DFMT_P8: str = "P8"; break;
+
976  case D3DFMT_L8: str = "L8"; break;
+
977  case D3DFMT_A8L8: str = "A8L8"; break;
+
978  case D3DFMT_A4L4: str = "A4L4"; break;
+
979  case D3DFMT_V8U8: str = "V8U8"; break;
+
980  case D3DFMT_L6V5U5: str = "L6V5U5"; break;
+
981  case D3DFMT_X8L8V8U8: str = "X8L8V8U8"; break;
+
982  case D3DFMT_Q8W8V8U8: str = "Q8W8V8U8"; break;
+
983  case D3DFMT_V16U16: str = "V16U16"; break;
+
984  case D3DFMT_A2W10V10U10: str = "A2W10V10U10"; break;
+
985  case D3DFMT_UYVY: str = "UYVY"; break;
+
986  case D3DFMT_YUY2: str = "YUY2"; break;
+
987  case D3DFMT_DXT1: str = "DXT1"; break;
+
988  case D3DFMT_DXT2: str = "DXT2"; break;
+
989  case D3DFMT_DXT3: str = "DXT3"; break;
+
990  case D3DFMT_DXT4: str = "DXT4"; break;
+
991  case D3DFMT_DXT5: str = "DXT5"; break;
+
992  case D3DFMT_D16_LOCKABLE: str = "D16_LOCKABLE"; break;
+
993  case D3DFMT_D32: str = "D32"; break;
+
994  case D3DFMT_D15S1: str = "D15S1"; break;
+
995  case D3DFMT_D24S8: str = "D24S8"; break;
+
996  case D3DFMT_D24X8: str = "D24X8"; break;
+
997  case D3DFMT_D24X4S4: str = "D24X4S4"; break;
+
998  case D3DFMT_D16: str = "D16"; break;
+
999  case D3DFMT_L16: str = "L16"; break;
+
1000  case D3DFMT_VERTEXDATA: str = "VERTEXDATA"; break;
+
1001  case D3DFMT_INDEX16: str = "INDEX16"; break;
+
1002  case D3DFMT_INDEX32: str = "INDEX32"; break;
+
1003  case D3DFMT_Q16W16V16U16: str = "Q16W16V16U16"; break;
+
1004  case D3DFMT_MULTI2_ARGB8: str = "MULTI2_ARGB8"; break;
+
1005  case D3DFMT_R16F: str = "R16F"; break;
+
1006  case D3DFMT_G16R16F: str = "G16R16F"; break;
+
1007  case D3DFMT_A16B16G16R16F: str = "A16B16G16R16F"; break;
+
1008  case D3DFMT_R32F: str = "R32F"; break;
+
1009  case D3DFMT_G32R32F: str = "G32R32F"; break;
+
1010  case D3DFMT_A32B32G32R32F: str = "A32B32G32R32F"; break;
+
1011  case D3DFMT_CxV8U8: str = "CxV8U8"; break;
+
1012  default: str = "Unknown format"; break;
+
1013  }
+
1014 
+
1015  return str;
+
1016 }
+
1017 
+
1018 
+
1019 // +--------------------------------------------------------------------+
+
1020 
+
1021 VideoDX9AdapterInfo::VideoDX9AdapterInfo()
+
1022 : adapter_ordinal(0)
+
1023 {
+
1024  ZeroMemory(&adapter_identifier, sizeof(adapter_identifier));
+
1025 }
+
1026 
+
1027 VideoDX9AdapterInfo::~VideoDX9AdapterInfo()
+
1028 {
+
1029  display_mode_list.destroy();
+
1030  device_info_list.destroy();
+
1031 }
+
1032 
+
1033 const char*
+
1034 VideoDX9AdapterInfo::GetDescription() const
+
1035 {
+
1036  return adapter_identifier.Description;
+
1037 }
+
1038 
+
1039 // +--------------------------------------------------------------------+
+
1040 
+
1041 VideoDX9DeviceInfo::VideoDX9DeviceInfo()
+
1042 : adapter_ordinal(0), device_type(D3DDEVTYPE_HAL)
+
1043 {
+
1044  ZeroMemory(&caps, sizeof(caps));
+
1045 }
+
1046 
+
1047 VideoDX9DeviceInfo::~VideoDX9DeviceInfo()
+
1048 {
+
1049  device_combo_list.destroy();
+
1050 }
+
1051 
+
1052 // +--------------------------------------------------------------------+
+
1053 
+
1054 VideoDX9DeviceCombo::VideoDX9DeviceCombo()
+
1055 : adapter_ordinal(0), device_type(D3DDEVTYPE_HAL),
+
1056 adapter_format((D3DFORMAT) 0),
+
1057 back_buffer_format((D3DFORMAT) 0),
+
1058 is_windowed(false)
+
1059 {
+
1060 }
+
1061 
+
1062 VideoDX9DeviceCombo::~VideoDX9DeviceCombo()
+
1063 {
+
1064  conflict_list.destroy();
+
1065 }
+
+
+ + + + -- cgit v1.1