From b829170121d3657369904ec62d8065606777a9ce Mon Sep 17 00:00:00 2001 From: Aki Date: Fri, 1 Oct 2021 18:54:04 +0200 Subject: Removed doxygen generated docs They can be rebuild anytime and are considered a build artifact/binary. --- Doc/doxygen/html/_video_d_x9_8cpp_source.html | 3734 ------------------------- 1 file changed, 3734 deletions(-) delete mode 100644 Doc/doxygen/html/_video_d_x9_8cpp_source.html (limited to 'Doc/doxygen/html/_video_d_x9_8cpp_source.html') diff --git a/Doc/doxygen/html/_video_d_x9_8cpp_source.html b/Doc/doxygen/html/_video_d_x9_8cpp_source.html deleted file mode 100644 index 2c35b53..0000000 --- a/Doc/doxygen/html/_video_d_x9_8cpp_source.html +++ /dev/null @@ -1,3734 +0,0 @@ - - - - - -Starshatter_Open: D:/SRC/StarshatterSVN/nGenEx/VideoDX9.cpp Source File - - - - - - - - - - - - - -
-
- - - - - - -
-
Starshatter_Open -
-
Open source Starshatter engine
-
-
- - - - - -
-
- -
-
-
- -
- - - - -
- -
- -
-
-
VideoDX9.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: VideoDX9.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 "VideoDX9.h"
-
17 #include "VideoDX9Enum.h"
-
18 #include "VideoDX9VertexBuffer.h"
-
19 #include "TexDX9.h"
-
20 #include "TexCubeDX9.h"
-
21 #include "Camera.h"
-
22 #include "Color.h"
-
23 #include "DataLoader.h"
-
24 #include "Polygon.h"
-
25 #include "Light.h"
-
26 #include "Solid.h"
-
27 
-
28 // +--------------------------------------------------------------------+
-
29 
-
30 void Print(const char* msg, ...);
-
31 char* D3DErrStr(HRESULT dderr);
-
32 void VideoDX9Error(const char* msg, HRESULT dderr);
-
33 static TexCacheDX9* texcache = 0;
-
34 static TexCubeDX9* environment_cube = 0;
-
35 static bool surface_has_tangent_data = false;
-
36 static Light* main_light;
-
37 static Light* back_light;
-
38 static D3DXMATRIX matrixWorld;
-
39 static D3DXMATRIX matrixView;
-
40 static D3DXMATRIX matrixProj;
-
41 static D3DXMATRIX matrixWorldInverse;
-
42 
-
43 extern int VD3D_describe_things;
-
44 
-
45 #ifndef RELEASE
-
46 #define RELEASE(x) if (x) { x->Release(); x=NULL; }
-
47 #endif
-
48 
-
49 #ifndef F2DW
-
50 #define F2DW(x) (*(DWORD*)(&x))
-
51 #endif
-
52 
-
53 #ifndef DW2I
-
54 #define DW2I(x) (*(int*)(&x))
-
55 #endif
-
56 
-
57 // +--------------------------------------------------------------------+
-
58 
-
59 typedef HRESULT (WINAPI * LPDDCE)(GUID FAR *, LPVOID *, REFIID , IUnknown FAR *);
-
60 
-
61 static D3DMATRIX identity_matrix = {
-
62  FLOAT(1.0), FLOAT(0.0), FLOAT(0.0), FLOAT(0.0),
-
63  FLOAT(0.0), FLOAT(1.0), FLOAT(0.0), FLOAT(0.0),
-
64  FLOAT(0.0), FLOAT(0.0), FLOAT(1.0), FLOAT(0.0),
-
65  FLOAT(0.0), FLOAT(0.0), FLOAT(0.0), FLOAT(1.0)
-
66 };
-
67 
-
68 // +--------------------------------------------------------------------+
-
69 
-
70 List<Model> model_clients;
-
71 
-
72 class VideoDX9SurfaceData : public VideoPrivateData
-
73 {
-
74 public:
-
75  VideoDX9SurfaceData(Model* m) : model(m), vertex_buffer(0), index_buffer(0) {
-
76  if (!model_clients.contains(model))
-
77  model_clients.append(model);
-
78  }
-
79 
-
80  virtual ~VideoDX9SurfaceData() {
-
81  model_clients.remove(model);
-
82 
-
83  delete vertex_buffer;
-
84  delete index_buffer;
-
85  }
-
86 
-
87  enum { TYPE = 9001 };
-
88  virtual int GetType() const { return TYPE; }
-
89 
-
90  Model* model;
-
91  VideoDX9VertexBuffer* vertex_buffer;
-
92  VideoDX9IndexBuffer* index_buffer;
-
93 };
-
94 
-
95 class VideoDX9SegmentData : public VideoPrivateData
-
96 {
-
97 public:
-
98  VideoDX9SegmentData() : first_vert(0), num_verts(0), first_index(0), num_tris(0) { }
-
99  virtual ~VideoDX9SegmentData() { }
-
100 
-
101  enum { TYPE = 9002 };
-
102  virtual int GetType() const { return TYPE; }
-
103 
-
104  int first_vert;
-
105  int num_verts;
-
106  int first_index;
-
107  int num_tris;
-
108 };
-
109 
-
110 // +--------------------------------------------------------------------+
-
111 
-
112 static int d3dstate_table[] = {
-
113  D3DRS_FILLMODE, // FILL_MODE
-
114  D3DRS_SHADEMODE, // SHADE_MODE
-
115  D3DRS_LIGHTING, // LIGHTING_ENABLE
-
116  D3DRS_ZENABLE, // Z_ENABLE
-
117  D3DRS_ZWRITEENABLE, // Z_WRITE_ENABLE
-
118  D3DRS_DEPTHBIAS, // Z_BIAS
-
119  0, // TEXTURE_FILTER
-
120  D3DRS_DITHERENABLE, // DITHER_ENABLE
-
121  D3DRS_SPECULARENABLE, // SPECULAR_ENABLE
-
122  D3DRS_FOGENABLE, // FOG_ENABLE
-
123  D3DRS_FOGCOLOR, // FOG_COLOR
-
124  D3DRS_FOGDENSITY, // FOG_DENSITY
-
125  D3DRS_STENCILENABLE, // STENCIL_ENABLE
-
126  0x11111111, // TEXTURE_WRAP (special case)
-
127  0 // LIGHTING_PASS
-
128 };
-
129 
-
130 static const int NUM_SCREEN_VERTS = 1024;
-
131 static const int NUM_SCREEN_INDICES = NUM_SCREEN_VERTS * 2;
-
132 
-
133 // +--------------------------------------------------------------------+
-
134 
-
135 struct VideoDX9ScreenVertex
-
136 {
-
137  FLOAT sx, sy, sz, rhw;
-
138  DWORD diffuse;
-
139  FLOAT tu, tv;
-
140 
-
141  static DWORD FVF;
-
142 };
-
143 
-
144 DWORD VideoDX9ScreenVertex::FVF = D3DFVF_XYZRHW |
-
145 D3DFVF_DIFFUSE |
-
146 D3DFVF_TEX1;
-
147 
-
148 struct VideoDX9NormalVertex
-
149 {
-
150  FLOAT x, y, z;
-
151  FLOAT nx, ny, nz;
-
152  FLOAT t0u, t0v;
-
153  FLOAT t1u, t1v;
-
154  FLOAT tx, ty, tz;
-
155  FLOAT bx, by, bz;
-
156 
-
157  static DWORD FVF;
-
158 };
-
159 
-
160 DWORD VideoDX9NormalVertex::FVF = 0;
-
161 
-
162 // Global Vertex Declaration shared by shaders
-
163 D3DVERTEXELEMENT9 videoDX9NormalVertexElements[] =
-
164 {
-
165  { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
-
166  { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
-
167  { 0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
-
168  { 0, 32, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
-
169  { 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 2 },
-
170  { 0, 52, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 3 },
-
171  D3DDECL_END()
-
172 };
-
173 
-
174 struct VideoDX9SolidVertex
-
175 {
-
176  FLOAT x, y, z;
-
177  FLOAT nx, ny, nz;
-
178  FLOAT tu, tv;
-
179 
-
180  static DWORD FVF;
-
181 };
-
182 
-
183 DWORD VideoDX9SolidVertex::FVF = D3DFVF_XYZ |
-
184 D3DFVF_NORMAL |
-
185 D3DFVF_TEX1 |
-
186 D3DFVF_TEXCOORDSIZE2(0);
-
187 
-
188 struct VideoDX9LuminousVertex
-
189 {
-
190  FLOAT x, y, z;
-
191  DWORD diffuse;
-
192  FLOAT tu, tv;
-
193 
-
194  static DWORD FVF;
-
195 };
-
196 
-
197 DWORD VideoDX9LuminousVertex::FVF = D3DFVF_XYZ |
-
198 D3DFVF_DIFFUSE |
-
199 D3DFVF_TEX1 |
-
200 D3DFVF_TEXCOORDSIZE2(0);
-
201 
-
202 struct VideoDX9DetailVertex
-
203 {
-
204  FLOAT x, y, z;
-
205  DWORD diffuse;
-
206  DWORD specular;
-
207  FLOAT tu, tv;
-
208  FLOAT tu1, tv1;
-
209 
-
210  static DWORD FVF;
-
211 };
-
212 
-
213 DWORD VideoDX9DetailVertex::FVF = D3DFVF_XYZ |
-
214 D3DFVF_DIFFUSE |
-
215 D3DFVF_SPECULAR |
-
216 D3DFVF_TEX2;
-
217 
-
218 struct VideoDX9LineVertex
-
219 {
-
220  FLOAT x, y, z;
-
221  DWORD diffuse;
-
222 
-
223  static DWORD FVF;
-
224 };
-
225 
-
226 DWORD VideoDX9LineVertex::FVF = D3DFVF_XYZ |
-
227 D3DFVF_DIFFUSE;
-
228 
-
229 enum {
-
230  DX9_STRATEGY_NONE,
-
231  DX9_STRATEGY_SIMPLE,
-
232  DX9_STRATEGY_GLOW,
-
233  DX9_STRATEGY_SPECMAP,
-
234  DX9_STRATEGY_EMISSIVE,
-
235  DX9_STRATEGY_SPEC_EMISSIVE,
-
236  DX9_STRATEGY_BLEND,
-
237  DX9_STRATEGY_BLEND_DETAIL
-
238 };
-
239 
-
240 // +--------------------------------------------------------------------+
-
241 
-
242 static VideoDX9* video_dx9_instance = 0;
-
243 
-
244 VideoDX9::VideoDX9(const HWND& window, VideoSettings* vs)
-
245 : width(0), height(0), bpp(0), hwnd(window), surface(0),
-
246 d3d(0), d3ddevice(0), device_lost(false), fade(0),
-
247 zdepth(0), gamma(128), num_verts(0), first_vert(0),
-
248 current_texture(0), screen_vbuf(0), screen_ibuf(0),
-
249 font_verts(0), font_indices(0), font_nverts(0),
-
250 nlights(0), use_material(0), d3dx_font(0),
-
251 segment_material(0), strategy(0), passes(0),
-
252 screen_line_verts(0), line_verts(0),
-
253 vertex_declaration(0),
-
254 magic_fx(0), magic_fx_code(0), magic_fx_code_len(0)
-
255 {
-
256  video_dx9_instance = this;
-
257 
-
258  Print("\n********************************\n");
-
259  Print("* Direct 3D version 9 *\n");
-
260  Print("********************************\n\n");
-
261 
-
262  status = VIDEO_ERR;
-
263  HRESULT err = E_OUTOFMEMORY;
-
264 
-
265  d3d = Direct3DCreate9(D3D_SDK_VERSION);
-
266  dx9enum = new(__FILE__,__LINE__) VideoDX9Enum(d3d);
-
267 
-
268  if (d3d && dx9enum) {
-
269  if (vs) {
-
270  dx9enum->req_fullscreen = vs->is_windowed ? false : true;
-
271  dx9enum->req_windowed = vs->is_windowed ? true : false;
-
272  dx9enum->min_stencil_bits = vs->shadows ? 8 : 0;
-
273  dx9enum->uses_depth_buffer = true;
-
274  }
-
275  else {
-
276  dx9enum->req_fullscreen = video_settings.is_windowed ? false : true;
-
277  dx9enum->req_windowed = video_settings.is_windowed ? true : false;
-
278  dx9enum->min_stencil_bits = video_settings.shadows ? 8 : 0;
-
279  dx9enum->uses_depth_buffer = true;
-
280  }
-
281 
-
282  err = dx9enum->Enumerate();
-
283 
-
284  if (FAILED(err)) {
-
285  VideoDX9Error("(ctor) could not enumerate dx9 properties", err);
-
286  delete dx9enum;
-
287  return;
-
288  }
-
289  }
-
290  else {
-
291  VideoDX9Error("(ctor) could not create enumerator", err);
-
292  return;
-
293  }
-
294 
-
295  SetVideoSettings(vs);
-
296 
-
297  if (video_settings.is_windowed)
-
298  dx9enum->SuggestWindowSettings(&video_settings);
-
299  else
-
300  dx9enum->SuggestFullscreenSettings(&video_settings);
-
301 
-
302  SetupParams();
-
303 
-
304  if (VD3D_describe_things > 2) {
-
305  Print("\nD3DPRESENT_PARAMETERS:\n");
-
306  Print(" BackBufferWidth: %d\n", d3dparams.BackBufferWidth);
-
307  Print(" BackBufferHeight: %d\n", d3dparams.BackBufferHeight);
-
308  Print(" BackBufferCount: %d\n", d3dparams.BackBufferCount);
-
309  Print(" BackBufferFormat: %s\n", VideoDX9DisplayMode::D3DFormatToString(d3dparams.BackBufferFormat));
-
310  Print(" Multisample Type: %d\n", d3dparams.MultiSampleType);
-
311  Print(" Multisample Qual: %d\n", d3dparams.MultiSampleQuality);
-
312  Print(" Swap Effect: %d\n", d3dparams.SwapEffect);
-
313  Print(" Device Window: %08X\n", d3dparams.hDeviceWindow);
-
314  Print(" Windowed: %s\n", d3dparams.Windowed ? "true" : "false");
-
315  Print(" Enable Depth/Stencil: %s\n", d3dparams.EnableAutoDepthStencil ? "true" : "false");
-
316  Print(" Depth/Stencil Format: %s\n", VideoDX9DisplayMode::D3DFormatToString(d3dparams.AutoDepthStencilFormat));
-
317  Print(" Flags: %08X\n", d3dparams.Flags);
-
318  Print(" Fullscreen Refresh: %d Hz\n", d3dparams.FullScreen_RefreshRateInHz);
-
319 
-
320  switch (d3dparams.PresentationInterval) {
-
321  case D3DPRESENT_INTERVAL_IMMEDIATE:
-
322  Print(" Present Interval: IMMEDIATE\n");
-
323  break;
-
324 
-
325  case D3DPRESENT_INTERVAL_DEFAULT:
-
326  Print(" Present Interval: DEFAULT\n");
-
327  break;
-
328 
-
329  case D3DPRESENT_INTERVAL_ONE:
-
330  Print(" Present Interval: ONE\n");
-
331  break;
-
332 
-
333  case D3DPRESENT_INTERVAL_TWO:
-
334  Print(" Present Interval: TWO\n");
-
335  break;
-
336 
-
337  case D3DPRESENT_INTERVAL_THREE:
-
338  Print(" Present Interval: THREE\n");
-
339  break;
-
340 
-
341  case D3DPRESENT_INTERVAL_FOUR:
-
342  Print(" Present Interval: FOUR\n");
-
343  break;
-
344 
-
345  default:
-
346  Print(" Present Interval: Unknown (%d)\n", d3dparams.PresentationInterval);
-
347  break;
-
348  }
-
349 
-
350  Print("\n");
-
351  }
-
352 
-
353  Print(" Creating Video Device for HWND = %08x\n", window);
-
354 
-
355  err = d3d->CreateDevice(D3DADAPTER_DEFAULT,
-
356  D3DDEVTYPE_HAL,
-
357  window,
-
358  D3DCREATE_HARDWARE_VERTEXPROCESSING,
-
359  &d3dparams,
-
360  &d3ddevice);
-
361 
-
362  if (FAILED(err)) {
-
363  VideoDX9Error("(ctor) could not create device", err);
-
364  return;
-
365  }
-
366 
-
367  width = video_settings.GetWidth();
-
368  height = video_settings.GetHeight();
-
369  bpp = video_settings.GetDepth();
-
370 
-
371  shadow_enabled = vs->shadows;
-
372  bump_enabled = vs->bumpmaps;
-
373  spec_enabled = vs->specmaps;
-
374 
-
375  render_state[FILL_MODE] = FILL_SOLID;
-
376  render_state[SHADE_MODE] = SHADE_GOURAUD;
-
377  render_state[Z_ENABLE] = false;
-
378  render_state[Z_WRITE_ENABLE] = false;
-
379  render_state[Z_BIAS] = 0;
-
380  render_state[TEXTURE_FILTER] = FILTER_LINEAR;
-
381  render_state[DITHER_ENABLE] = false;
-
382  render_state[SPECULAR_ENABLE] = true;
-
383  render_state[FOG_ENABLE] = false;
-
384  render_state[FOG_COLOR] = 0;
-
385  render_state[FOG_DENSITY] = 0;
-
386  render_state[STENCIL_ENABLE] = false;
-
387  render_state[TEXTURE_WRAP] = true;
-
388  render_state[LIGHTING_PASS] = 0;
-
389 
-
390  ZeroMemory(&rect, sizeof(rect));
-
391 
-
392  if (!texcache)
-
393  texcache = new(__FILE__,__LINE__) TexCacheDX9(this);
-
394 
-
395  if (texcache)
-
396  texcache->count++;
-
397 
-
398  if (VD3D_describe_things > 0) {
-
399  DWORD vmf = VidMemFree() / (1024 * 1024);
-
400  Print(" Available Texture Memory: %d MB\n\n", vmf);
-
401  }
-
402 
-
403  if (CreateBuffers()) {
-
404  d3ddevice->SetRenderState(D3DRS_ALPHATESTENABLE, false);
-
405  d3ddevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
-
406 
-
407  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
-
408  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
409  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
-
410  d3ddevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
411  d3ddevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
412  d3ddevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
-
413 
-
414  status = VIDEO_OK;
-
415  }
-
416 
-
417  ZeroMemory(font_name, 64);
-
418  font_size = 0;
-
419  font_bold = false;
-
420  font_ital = false;
-
421 }
-
422 
-
423 // +--------------------------------------------------------------------+
-
424 
-
425 VideoDX9::~VideoDX9()
-
426 {
-
427  DestroyBuffers();
-
428 
-
429  texcache->count--;
-
430  if (!texcache->count) {
-
431  delete texcache;
-
432  texcache = 0;
-
433  }
-
434 
-
435  delete environment_cube;
-
436  delete dx9enum;
-
437 
-
438  RELEASE(d3dx_font);
-
439  RELEASE(d3ddevice);
-
440  RELEASE(d3d);
-
441 
-
442  if (magic_fx_code)
-
443  delete [] magic_fx_code;
-
444 
-
445  Print(" VideoDX9: shutdown\n");
-
446  video_dx9_instance = 0;
-
447 }
-
448 
-
449 IDirect3DDevice9*
-
450 VideoDX9::GetD3DDevice9()
-
451 {
-
452  if (video_dx9_instance)
-
453  return video_dx9_instance->d3ddevice;
-
454 
-
455  return 0;
-
456 }
-
457 
-
458 // +--------------------------------------------------------------------+
-
459 
-
460 bool
-
461 VideoDX9::SetupParams()
-
462 {
-
463  if (!dx9enum || dx9enum->NumAdapters() < 1) {
-
464  status = VIDEO_ERR;
-
465  return false;
-
466  }
-
467 
-
468  int adapter_index = video_settings.GetAdapterIndex();
-
469 
-
470  if (adapter_index < 0 || adapter_index >= dx9enum->NumAdapters()) {
-
471  ::Print("WARNING: VideoDX9 could not select adapter %d (max=%d)\n",
-
472  adapter_index, dx9enum->NumAdapters());
-
473 
-
474  adapter_index = 0;
-
475  }
-
476 
-
477  dx9enum->SelectAdapter(adapter_index);
-
478 
-
479  d3dparams.Windowed = video_settings.IsWindowed();
-
480  d3dparams.BackBufferCount = 2;
-
481  d3dparams.MultiSampleType = D3DMULTISAMPLE_NONE;
-
482  d3dparams.MultiSampleQuality = 0;
-
483  d3dparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
-
484  d3dparams.EnableAutoDepthStencil = dx9enum->uses_depth_buffer;
-
485  d3dparams.hDeviceWindow = hwnd;
-
486 
-
487  if (dx9enum->uses_depth_buffer) {
-
488  d3dparams.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
-
489  d3dparams.AutoDepthStencilFormat = (D3DFORMAT) video_settings.GetDepthStencilFormat();
-
490  }
-
491  else {
-
492  d3dparams.Flags = 0;
-
493  }
-
494 
-
495  d3dparams.Flags |= D3DPRESENTFLAG_DEVICECLIP;
-
496 
-
497  if (video_settings.IsWindowed()) {
-
498  d3dparams.BackBufferWidth = video_settings.window_width;
-
499  d3dparams.BackBufferHeight = video_settings.window_height;
-
500  d3dparams.BackBufferFormat = (D3DFORMAT) video_settings.GetBackBufferFormat();
-
501  d3dparams.FullScreen_RefreshRateInHz = 0;
-
502  d3dparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
-
503  }
-
504  else {
-
505  d3dparams.BackBufferWidth = video_settings.GetWidth();
-
506  d3dparams.BackBufferHeight = video_settings.GetHeight();
-
507  d3dparams.BackBufferFormat = (D3DFORMAT) video_settings.GetBackBufferFormat();
-
508  d3dparams.FullScreen_RefreshRateInHz = video_settings.GetRefreshRate();
-
509  d3dparams.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
-
510  }
-
511 
-
512  return true;
-
513 }
-
514 
-
515 
-
516 bool
-
517 VideoDX9::IsModeSupported(int w, int h, int b) const
-
518 {
-
519  if (dx9enum)
-
520  return dx9enum->IsModeSupported(w, h, b);
-
521 
-
522  return false;
-
523 }
-
524 
-
525 bool
-
526 VideoDX9::SetVideoSettings(const VideoSettings* vs)
-
527 {
-
528  // custom video settings:
-
529  if (vs) {
-
530  if (vs != &video_settings)
-
531  CopyMemory(&video_settings, vs, sizeof(VideoSettings));
-
532  }
-
533 
-
534  // default video settings:
-
535  else {
-
536  ZeroMemory(&video_settings, sizeof(VideoSettings));
-
537 
-
538  video_settings.fullscreen_mode.width = 800;
-
539  video_settings.fullscreen_mode.height = 600;
-
540  video_settings.fullscreen_mode.format = VideoMode::FMT_X8R8G8B8;
-
541  }
-
542 
-
543  return true;
-
544 }
-
545 
-
546 bool
-
547 VideoDX9::Reset(const VideoSettings* vs)
-
548 {
-
549  if (!d3ddevice || !SetVideoSettings(vs)) {
-
550  status = VIDEO_ERR;
-
551  return false;
-
552  }
-
553 
-
554  bool using_x_font = (d3dx_font != 0);
-
555 
-
556  RELEASE(d3dx_font);
-
557  InvalidateCache();
-
558  DestroyBuffers();
-
559  SetupParams();
-
560 
-
561  HRESULT hr = d3ddevice->Reset(&d3dparams);
-
562 
-
563  if (FAILED(hr)) {
-
564  VideoDX9Error("could not reset d3d device", hr);
-
565  status = VIDEO_ERR;
-
566  return false;
-
567  }
-
568 
-
569  // Store render target surface desc
-
570  IDirect3DSurface9* back_buffer;
-
571  d3ddevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &back_buffer);
-
572  back_buffer->GetDesc(&back_buffer_desc);
-
573  RELEASE(back_buffer);
-
574 
-
575  width = video_settings.GetWidth();
-
576  height = video_settings.GetHeight();
-
577  bpp = video_settings.GetDepth();
-
578 
-
579  shadow_enabled = vs->shadows;
-
580  bump_enabled = vs->bumpmaps;
-
581  spec_enabled = vs->specmaps;
-
582 
-
583 
-
584  if (CreateBuffers()) {
-
585  d3ddevice->SetRenderState(D3DRS_ALPHATESTENABLE, false);
-
586  d3ddevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
-
587 
-
588  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
-
589  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
590  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
-
591  d3ddevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
592  d3ddevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
593  d3ddevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
-
594 
-
595  D3DVIEWPORT9 view;
-
596 
-
597  hr = d3ddevice->GetViewport(&view);
-
598  if (SUCCEEDED(hr)) {
-
599  rect.x = view.X;
-
600  rect.y = view.Y;
-
601  rect.w = view.Width;
-
602  rect.h = view.Height;
-
603  }
-
604 
-
605  if (using_x_font)
-
606  UseXFont(font_name, font_size, font_bold, font_ital);
-
607 
-
608  status = VIDEO_OK;
-
609  }
-
610 
-
611  return status == VIDEO_OK;
-
612 }
-
613 
-
614 // +--------------------------------------------------------------------+
-
615 
-
616 bool
-
617 VideoDX9::CreateBuffers()
-
618 {
-
619  if (d3ddevice) {
-
620  UINT vertex_size = sizeof(VideoDX9ScreenVertex);
-
621  UINT index_size = sizeof(WORD);
-
622 
-
623  if (!screen_vbuf) {
-
624  screen_vbuf = new(__FILE__,__LINE__) VideoDX9VertexBuffer(
-
625  this,
-
626  NUM_SCREEN_VERTS,
-
627  vertex_size,
-
628  VideoDX9ScreenVertex::FVF,
-
629  D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY);
-
630  }
-
631 
-
632  if (!screen_ibuf) {
-
633  screen_ibuf = new(__FILE__,__LINE__) VideoDX9IndexBuffer(
-
634  this,
-
635  NUM_SCREEN_INDICES,
-
636  D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY);
-
637  }
-
638 
-
639  screen_line_verts = new(__FILE__,__LINE__) VideoDX9ScreenVertex[256];
-
640  line_verts = new(__FILE__,__LINE__) VideoDX9LineVertex[512];
-
641 
-
642  // create effects:
-
643  LPD3DXBUFFER code_buffer = 0;
-
644  DataLoader* loader = DataLoader::GetLoader();
-
645  HRESULT hr = E_FAIL;
-
646 
-
647  hr = d3ddevice->CreateVertexDeclaration(videoDX9NormalVertexElements,
-
648  &vertex_declaration);
-
649 
-
650  // The E - We want to load our shader from the standard filesystem by default, to allow for better modding.
-
651  if (video_settings.use_effects && !magic_fx_code) {
-
652  FILE* f;
-
653  ::fopen_s(&f, "magic.fx", "rb");
-
654 
-
655  if (f) {
-
656  ::fseek(f, 0, SEEK_END);
-
657  magic_fx_code_len = ftell(f);
-
658  ::fseek(f, 0, SEEK_SET);
-
659 
-
660  magic_fx_code = new(__FILE__,__LINE__) BYTE[magic_fx_code_len+1];
-
661  if (magic_fx_code) {
-
662  ::fread(magic_fx_code, magic_fx_code_len, 1, f);
-
663  magic_fx_code[magic_fx_code_len] = 0;
-
664  }
-
665  ::fclose(f);
-
666  } else if (loader) {
-
667  magic_fx_code_len = loader->LoadBuffer("magic.fx", magic_fx_code, true, true);
-
668  }
-
669  }
-
670 
-
671  if (video_settings.use_effects && magic_fx_code && magic_fx_code_len) {
-
672  hr = D3DXCreateEffect(d3ddevice,
-
673  magic_fx_code,
-
674  magic_fx_code_len,
-
675  0, 0, 0, 0,
-
676  &magic_fx,
-
677  &code_buffer);
-
678 
-
679  if (code_buffer) {
-
680  ::Print("ERROR - Failed to compile 'magic.fx'\n");
-
681  ::Print((const char*) code_buffer->GetBufferPointer());
-
682  ::Print("\n\n");
-
683  RELEASE(code_buffer);
-
684  }
-
685  }
-
686  }
-
687 
-
688  return screen_vbuf && screen_ibuf;
-
689 }
-
690 
-
691 bool
-
692 VideoDX9::DestroyBuffers()
-
693 {
-
694  if (line_verts) {
-
695  delete line_verts;
-
696  line_verts = 0;
-
697  }
-
698 
-
699  if (screen_line_verts) {
-
700  delete screen_line_verts;
-
701  screen_line_verts = 0;
-
702  }
-
703 
-
704  if (screen_vbuf) {
-
705  delete screen_vbuf;
-
706  screen_vbuf = 0;
-
707  }
-
708 
-
709  if (screen_ibuf) {
-
710  delete screen_ibuf;
-
711  screen_ibuf = 0;
-
712  }
-
713 
-
714  if (font_verts) {
-
715  delete [] font_verts;
-
716  font_verts = 0;
-
717  }
-
718 
-
719  if (font_indices) {
-
720  delete [] font_indices;
-
721  font_indices = 0;
-
722  }
-
723 
-
724  font_nverts = 0;
-
725 
-
726  RELEASE(vertex_declaration);
-
727  RELEASE(magic_fx);
-
728 
-
729  return true;
-
730 }
-
731 
-
732 // +--------------------------------------------------------------------+
-
733 
-
734 DWORD
-
735 VideoDX9::VidMemFree() const
-
736 {
-
737  UINT result = 0;
-
738 
-
739  if (d3ddevice)
-
740  result = d3ddevice->GetAvailableTextureMem();
-
741 
-
742  return result;
-
743 }
-
744 
-
745 int
-
746 VideoDX9::MaxTexSize() const
-
747 {
-
748  if (d3d && dx9enum && dx9enum->GetAdapterInfo()) {
-
749  VideoDX9DeviceInfo* dev_info = dx9enum->GetDeviceInfo(video_settings.GetDeviceType());
-
750 
-
751  if (dev_info) {
-
752  return (int) dev_info->caps.MaxTextureWidth;
-
753  }
-
754  }
-
755 
-
756  return 0;
-
757 }
-
758 
-
759 int
-
760 VideoDX9::MaxTexAspect() const
-
761 {
-
762  if (d3d && dx9enum && dx9enum->GetAdapterInfo()) {
-
763  VideoDX9DeviceInfo* dev_info = dx9enum->GetDeviceInfo(video_settings.GetDeviceType());
-
764 
-
765  if (dev_info) {
-
766  return (int) dev_info->caps.MaxTextureAspectRatio;
-
767  }
-
768  }
-
769 
-
770  return 0;
-
771 }
-
772 
-
773 // +--------------------------------------------------------------------+
-
774 
-
775 void
-
776 VideoDX9::RecoverSurfaces()
-
777 {
-
778  Print("VideoDX9::RecoverSurfaces()\n");
-
779 
-
780  HRESULT hr = D3D_OK;
-
781 
-
782  surface = 0;
-
783 
-
784  hr = d3ddevice->TestCooperativeLevel();
-
785 
-
786  if (hr == D3DERR_DEVICELOST) {
-
787  // This means that some app took exclusive mode access
-
788  // we need to sit in a loop till we get back to the right mode.
-
789  Print("D3DERR_DEVICELOST\n");
-
790 
-
791  do {
-
792  Sleep(500);
-
793  hr = d3ddevice->TestCooperativeLevel();
-
794  } while (hr == D3DERR_DEVICELOST);
-
795  }
-
796 
-
797  if (hr == D3DERR_DEVICENOTRESET) {
-
798  if (Reset(&video_settings))
-
799  hr = S_OK;
-
800  }
-
801 
-
802  if (SUCCEEDED(hr)) {
-
803  Print("* Invalidating Texture Cache\n");
-
804  // Re-fill the contents of textures which just got restored:
-
805  InvalidateCache();
-
806 
-
807  device_lost = false;
-
808  }
-
809 
-
810  Print("* Vid Mem Free: %8d\n", VidMemFree());
-
811  Print("* Recover Surfaces Complete.\n\n");
-
812 }
-
813 
-
814 // +--------------------------------------------------------------------+
-
815 
-
816 bool
-
817 VideoDX9::SetBackgroundColor(Color c)
-
818 {
-
819  background = c;
-
820  return true;
-
821 }
-
822 
-
823 //-----------------------------------------------------------------------------
-
824 // RampValue
-
825 //
-
826 // The gamma function with inputs in [0,255], scaled to a range with the
-
827 // default range appropriate for D3DGAMMARAMP.
-
828 //
-
829 inline WORD
-
830 RampValue(UINT i, double recip_gamma, double fade)
-
831 {
-
832  return (WORD) (65535.0 * fade * pow((double)i/255.f, recip_gamma));
-
833 }
-
834 
-
835 //-----------------------------------------------------------------------------
-
836 // ReciprocalGamma
-
837 //
-
838 // Given a gamma corrected i in [0,255], return 1/gamma
-
839 //
-
840 inline float
-
841 ReciprocalGamma(UINT i)
-
842 {
-
843  return logf(i/255.f)/logf(0.5f);
-
844 }
-
845 
-
846 //-----------------------------------------------------------------------------
-
847 // GammaValue
-
848 //
-
849 // Given a gamma corrected color channel value in [0,255], return the gamma.
-
850 //
-
851 inline float
-
852 GammaValue(UINT i)
-
853 {
-
854  return logf(0.5f)/logf(i/255.f);
-
855 }
-
856 
-
857 bool
-
858 VideoDX9::SetGammaLevel(int g)
-
859 {
-
860  HRESULT hr = E_FAIL;
-
861  double f = Color::GetFade();
-
862 
-
863  if (gamma != g || fade != f) {
-
864  if (d3ddevice) {
-
865  //::Print("VideoDX9 - SetGammaLevel(%d) fade = %f\n", g, f);
-
866 
-
867  // compute 1/gamma
-
868  float recip_gray = ReciprocalGamma(g);
-
869 
-
870  // compute i**(1/gamma) for all i and scale to range
-
871  for (UINT i = 0; i < 256; i++) {
-
872  int val = RampValue(i, recip_gray, f);
-
873 
-
874  gamma_ramp.red[i] = val;
-
875  gamma_ramp.green[i] = val;
-
876  gamma_ramp.blue[i] = val;
-
877  }
-
878 
-
879  d3ddevice->SetGammaRamp(0, D3DSGR_NO_CALIBRATION, &gamma_ramp);
-
880  hr = D3D_OK;
-
881  }
-
882 
-
883  gamma = g;
-
884  fade = f;
-
885  }
-
886 
-
887  return SUCCEEDED(hr);
-
888 }
-
889 
-
890 bool
-
891 VideoDX9::SetObjTransform(const Matrix& orient, const Point& loc)
-
892 {
-
893  HRESULT hr = E_FAIL;
-
894 
-
895  if (d3ddevice) {
-
896  D3DMATRIX world_matrix;
-
897  CreateD3DMatrix(world_matrix, orient, loc);
-
898  hr = d3ddevice->SetTransform(D3DTS_WORLD, &world_matrix);
-
899 
-
900  matrixWorld = world_matrix;
-
901  D3DXMatrixInverse(&matrixWorldInverse, 0, &matrixWorld);
-
902  }
-
903 
-
904  return SUCCEEDED(hr);
-
905 }
-
906 
-
907 // +--------------------------------------------------------------------+
-
908 
-
909 bool
-
910 VideoDX9::ClearAll()
-
911 {
-
912  HRESULT err;
-
913 
-
914  err = d3ddevice->Clear(0,
-
915  NULL,
-
916  D3DCLEAR_TARGET | D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER,
-
917  background.Value(),
-
918  1.0f,
-
919  0);
-
920 
-
921  if (FAILED(err)) {
-
922  static int report = 10;
-
923  if (report > 0) {
-
924  VideoDX9Error("Failed to clear device", err);
-
925  report--;
-
926  }
-
927  }
-
928 
-
929  return true;
-
930 }
-
931 
-
932 bool
-
933 VideoDX9::ClearDepthBuffer()
-
934 {
-
935  HRESULT err;
-
936 
-
937  err = d3ddevice->Clear(0,
-
938  NULL,
-
939  D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER,
-
940  0,
-
941  1.0f,
-
942  0);
-
943 
-
944  if (FAILED(err)) {
-
945  static int report = 10;
-
946  if (report > 0) {
-
947  VideoDX9Error("Failed to clear depth buffer", err);
-
948  report--;
-
949  }
-
950  }
-
951 
-
952  return true;
-
953 }
-
954 
-
955 // +--------------------------------------------------------------------+
-
956 
-
957 bool
-
958 VideoDX9::Present()
-
959 {
-
960  // Show the frame on the primary surface.
-
961  HRESULT err = d3ddevice->Present( NULL, NULL, NULL, NULL );
-
962 
-
963  if (FAILED(err)) {
-
964  if (err == D3DERR_DEVICELOST) {
-
965  device_lost = true;
-
966  }
-
967 
-
968  else {
-
969  static int report = 10;
-
970  if (report > 0) {
-
971  VideoDX9Error("Could not present frame", err);
-
972  report--;
-
973  }
-
974  }
-
975  }
-
976 
-
977  return true;
-
978 }
-
979 
-
980 // +--------------------------------------------------------------------+
-
981 
-
982 bool
-
983 VideoDX9::Pause()
-
984 {
-
985  return true;
-
986 }
-
987 
-
988 // +--------------------------------------------------------------------+
-
989 
-
990 bool
-
991 VideoDX9::Resume()
-
992 {
-
993  return true;
-
994 }
-
995 
-
996 // +--------------------------------------------------------------------+
-
997 
-
998 void
-
999 VideoDX9::PreloadSurface(Surface* s)
-
1000 {
-
1001  if (s)
-
1002  PrepareSurface(s);
-
1003 }
-
1004 
-
1005 void
-
1006 VideoDX9::PreloadTexture(Bitmap* tex)
-
1007 {
-
1008  if (texcache && tex)
-
1009  texcache->FindTexture(tex);
-
1010 }
-
1011 
-
1012 void
-
1013 VideoDX9::InvalidateCache()
-
1014 {
-
1015  ListIter<Model> iter = model_clients;
-
1016  while (++iter) {
-
1017  // remove each model from the list...
-
1018  Model* model = iter.removeItem();
-
1019 
-
1020  // ...so that the buffer destructor doesn't
-
1021  // do it and mess up the iterator.
-
1022  model->DeletePrivateData();
-
1023  }
-
1024 
-
1025  if (texcache)
-
1026  texcache->InvalidateCache();
-
1027 }
-
1028 
-
1029 // +--------------------------------------------------------------------+
-
1030 
-
1031 void
-
1032 VideoDX9::CreateD3DMatrix(D3DMATRIX& result, const Matrix& m, const Point& p)
-
1033 {
-
1034  result._11 = (float) m.elem[0][0];
-
1035  result._12 = (float) m.elem[1][0];
-
1036  result._13 = (float) m.elem[2][0];
-
1037  result._14 = 0.0f;
-
1038 
-
1039  result._21 = (float) m.elem[0][1];
-
1040  result._22 = (float) m.elem[1][1];
-
1041  result._23 = (float) m.elem[2][1];
-
1042  result._24 = 0.0f;
-
1043 
-
1044  result._31 = (float) m.elem[0][2];
-
1045  result._32 = (float) m.elem[1][2];
-
1046  result._33 = (float) m.elem[2][2];
-
1047  result._34 = 0.0f;
-
1048 
-
1049  result._41 = (float) p.x;
-
1050  result._42 = (float) p.y;
-
1051  result._43 = (float) p.z;
-
1052  result._44 = 1.0f;
-
1053 }
-
1054 
-
1055 void
-
1056 VideoDX9::CreateD3DMatrix(D3DMATRIX& result, const Matrix& m, const Vec3& v)
-
1057 {
-
1058  result._11 = (float) m.elem[0][0];
-
1059  result._12 = (float) m.elem[1][0];
-
1060  result._13 = (float) m.elem[2][0];
-
1061  result._14 = 0.0f;
-
1062 
-
1063  result._21 = (float) m.elem[0][1];
-
1064  result._22 = (float) m.elem[1][1];
-
1065  result._23 = (float) m.elem[2][1];
-
1066  result._24 = 0.0f;
-
1067 
-
1068  result._31 = (float) m.elem[0][2];
-
1069  result._32 = (float) m.elem[1][2];
-
1070  result._33 = (float) m.elem[2][2];
-
1071  result._34 = 0.0f;
-
1072 
-
1073  result._41 = v.x;
-
1074  result._42 = v.y;
-
1075  result._43 = v.z;
-
1076  result._44 = 1.0f;
-
1077 }
-
1078 
-
1079 void
-
1080 VideoDX9::CreateD3DMaterial(D3DMATERIAL9& result, const Material& mtl)
-
1081 {
-
1082  CopyMemory(&result.Diffuse, &mtl.Kd, sizeof(D3DCOLORVALUE));
-
1083  CopyMemory(&result.Ambient, &mtl.Ka, sizeof(D3DCOLORVALUE));
-
1084  CopyMemory(&result.Specular, &mtl.Ks, sizeof(D3DCOLORVALUE));
-
1085  CopyMemory(&result.Emissive, &mtl.Ke, sizeof(D3DCOLORVALUE));
-
1086 
-
1087  result.Power = mtl.power;
-
1088 }
-
1089 
-
1090 
-
1091 // +--------------------------------------------------------------------+
-
1092 
-
1093 bool
-
1094 VideoDX9::Capture(Bitmap& bmp)
-
1095 {
-
1096  if (d3ddevice) {
-
1097  HRESULT hr = E_FAIL;
-
1098  LPDIRECT3DSURFACE9 pSurf=NULL, pTempSurf=NULL;
-
1099  D3DSURFACE_DESC desc;
-
1100  D3DDISPLAYMODE dm;
-
1101 
-
1102  // get display dimensions
-
1103  // this will be the dimensions of the front buffer
-
1104  hr = d3ddevice->GetDisplayMode(0, &dm);
-
1105 
-
1106  if (FAILED(hr))
-
1107  VideoDX9Error("VideoDX9::Capture - Can't get display mode!", hr);
-
1108 
-
1109  desc.Width = dm.Width;
-
1110  desc.Height = dm.Height;
-
1111  desc.Format = D3DFMT_A8R8G8B8;
-
1112 
-
1113  hr = d3ddevice->CreateOffscreenPlainSurface(
-
1114  desc.Width,
-
1115  desc.Height,
-
1116  desc.Format,
-
1117  D3DPOOL_SYSTEMMEM,
-
1118  &pTempSurf,
-
1119  NULL);
-
1120 
-
1121  if (FAILED(hr)) {
-
1122  VideoDX9Error("VideoDX9::Capture - Cannot create offscreen buffer 1", hr);
-
1123  return false;
-
1124  }
-
1125 
-
1126  hr = d3ddevice->GetFrontBufferData(0, pTempSurf);
-
1127 
-
1128  if (FAILED(hr)) {
-
1129  RELEASE(pTempSurf);
-
1130  VideoDX9Error("VideoDX9::Capture - Can't get front buffer", hr);
-
1131  return false;
-
1132  }
-
1133 
-
1134 
-
1135  if (video_settings.IsWindowed()) {
-
1136  POINT pt={0, 0};
-
1137  RECT srcRect;
-
1138 
-
1139  // capture only the client area of the screen:
-
1140  ::GetClientRect(hwnd, &srcRect);
-
1141  ::ClientToScreen(hwnd, (LPPOINT) &srcRect);
-
1142  srcRect.right += srcRect.left;
-
1143  srcRect.bottom += srcRect.top;
-
1144 
-
1145  desc.Width = srcRect.right - srcRect.left;
-
1146  desc.Height = srcRect.bottom - srcRect.top;
-
1147  desc.Format = D3DFMT_A8R8G8B8; // this is what we get from the screen, so stick with it
-
1148 
-
1149  // NB we can't lock the back buffer direct because it's no created that way
-
1150  // and to do so hits performance, so copy to another surface
-
1151  // Must be the same format as the source surface
-
1152  hr = d3ddevice->CreateOffscreenPlainSurface(
-
1153  desc.Width,
-
1154  desc.Height,
-
1155  desc.Format,
-
1156  D3DPOOL_DEFAULT,
-
1157  &pSurf,
-
1158  NULL);
-
1159 
-
1160  if (FAILED(hr)) {
-
1161  RELEASE(pSurf);
-
1162  VideoDX9Error("VideoDX9::Capture - Cannot create offscreen buffer 2", hr);
-
1163  return false;
-
1164  }
-
1165 
-
1166  // Copy
-
1167  hr = d3ddevice->UpdateSurface(pTempSurf, &srcRect, pSurf, &pt);
-
1168 
-
1169  if (FAILED(hr)) {
-
1170  RELEASE(pTempSurf);
-
1171  RELEASE(pSurf);
-
1172  VideoDX9Error("VideoDX9::Capture - Cannot update surface", hr);
-
1173  return false;
-
1174  }
-
1175 
-
1176  RELEASE(pTempSurf);
-
1177  pTempSurf = pSurf;
-
1178  pSurf = NULL;
-
1179  }
-
1180 
-
1181  D3DLOCKED_RECT lockedRect;
-
1182  hr = pTempSurf->LockRect(&lockedRect, NULL,
-
1183  D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK);
-
1184 
-
1185  if (FAILED(hr)) {
-
1186  VideoDX9Error("VideoDX9::Capture - can't lock rect", hr);
-
1187  RELEASE(pTempSurf);
-
1188  return false;
-
1189  }
-
1190 
-
1191  // Allocate color buffer
-
1192  DWORD* buffer = new DWORD[desc.Width * desc.Height];
-
1193  BYTE* src = (BYTE*) lockedRect.pBits;
-
1194  BYTE* dst = (BYTE*) buffer;
-
1195  Color clr;
-
1196 
-
1197  for (DWORD y = 0; y < desc.Height; y++) {
-
1198  BYTE *pRow = src;
-
1199 
-
1200  for (DWORD x = 0; x < desc.Width; x++) {
-
1201  switch(desc.Format) {
-
1202  case D3DFMT_R5G6B5:
-
1203  clr = Color::Unformat(*((WORD*) (pRow)));
-
1204 
-
1205  *dst++ = (BYTE) clr.Red();
-
1206  *dst++ = (BYTE) clr.Green();
-
1207  *dst++ = (BYTE) clr.Blue();
-
1208  *dst++ = 255;
-
1209  break;
-
1210 
-
1211  case D3DFMT_A8R8G8B8:
-
1212  case D3DFMT_X8R8G8B8:
-
1213  *dst++ = pRow[0]; // R
-
1214  *dst++ = pRow[1]; // G
-
1215  *dst++ = pRow[2]; // B
-
1216  *dst++ = 255;
-
1217 
-
1218  pRow += 4;
-
1219  break;
-
1220 
-
1221  case D3DFMT_R8G8B8:
-
1222  *dst++ = pRow[0]; // R
-
1223  *dst++ = pRow[1]; // G
-
1224  *dst++ = pRow[2]; // B
-
1225  *dst++ = 255;
-
1226 
-
1227  pRow += 3;
-
1228  break;
-
1229  }
-
1230 
-
1231  }
-
1232 
-
1233  src += lockedRect.Pitch;
-
1234  }
-
1235 
-
1236  bmp.CopyHighColorImage(desc.Width, desc.Height, buffer);
-
1237 
-
1238  delete [] buffer;
-
1239 
-
1240  RELEASE(pTempSurf);
-
1241  RELEASE(pSurf);
-
1242 
-
1243  return SUCCEEDED(hr);
-
1244  }
-
1245 
-
1246  return false;
-
1247 }
-
1248 
-
1249 // +--------------------------------------------------------------------+
-
1250 
-
1251 bool
-
1252 VideoDX9::GetWindowRect(Rect& r)
-
1253 {
-
1254  if (d3ddevice && (rect.w < 1 || rect.h < 1)) {
-
1255  D3DVIEWPORT9 view;
-
1256  HRESULT hr = d3ddevice->GetViewport(&view);
-
1257  if (SUCCEEDED(hr)) {
-
1258  rect.x = view.X;
-
1259  rect.y = view.Y;
-
1260  rect.w = view.Width;
-
1261  rect.h = view.Height;
-
1262  }
-
1263  }
-
1264 
-
1265  r = rect;
-
1266  return true;
-
1267 }
-
1268 
-
1269 // +--------------------------------------------------------------------+
-
1270 
-
1271 bool
-
1272 VideoDX9::SetWindowRect(const Rect& r)
-
1273 {
-
1274  return SetViewport(r.x, r.y, r.w, r.h);
-
1275 }
-
1276 
-
1277 // +--------------------------------------------------------------------+
-
1278 
-
1279 bool
-
1280 VideoDX9::SetViewport(int x, int y, int w, int h)
-
1281 {
-
1282  if (!d3d || !d3ddevice)
-
1283  return false;
-
1284 
-
1285  HRESULT hr;
-
1286 
-
1287  // set up the viewport according to args:
-
1288  D3DVIEWPORT9 view;
-
1289 
-
1290  view.X = x;
-
1291  view.Y = y;
-
1292  view.Width = w;
-
1293  view.Height = h;
-
1294  view.MinZ = 0.0f;
-
1295  view.MaxZ = 1.0f;
-
1296 
-
1297  hr = d3ddevice->SetViewport(&view);
-
1298  if (FAILED(hr)) {
-
1299  VideoDX9Error("could not initialize viewport", hr);
-
1300  return false;
-
1301  }
-
1302 
-
1303  // set up the render state:
-
1304  for (int i = FILL_MODE; i < TEXTURE_WRAP; i++) {
-
1305  if (d3dstate_table[i]) {
-
1306  d3ddevice->SetRenderState((D3DRENDERSTATETYPE) d3dstate_table[i], render_state[i]);
-
1307  }
-
1308  }
-
1309 
-
1310  d3ddevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
-
1311 
-
1312  rect.x = x;
-
1313  rect.y = y;
-
1314  rect.w = w;
-
1315  rect.h = h;
-
1316 
-
1317  return true;
-
1318 }
-
1319 
-
1320 // +--------------------------------------------------------------------+
-
1321 
-
1322 bool
-
1323 VideoDX9::SetAmbient(Color c)
-
1324 {
-
1325  ambient = c;
-
1326  return true;
-
1327 }
-
1328 
-
1329 bool
-
1330 VideoDX9::SetLights(const List<Light>& lights)
-
1331 {
-
1332  if (d3ddevice) {
-
1333  main_light = 0;
-
1334  back_light = 0;
-
1335 
-
1336  ListIter<Light> iter = (List<Light>&) lights;
-
1337  int index = -1;
-
1338 
-
1339  while (++iter) {
-
1340  Light* light = iter.value();
-
1341 
-
1342  if (light->IsActive()) {
-
1343  D3DLIGHT9 d3d_light;
-
1344  ZeroMemory(&d3d_light, sizeof(d3d_light));
-
1345  d3d_light.Type = (D3DLIGHTTYPE) light->Type();
-
1346 
-
1347  if (light->Type() == Light::LIGHT_DIRECTIONAL) {
-
1348  d3d_light.Direction.x = (float) (-light->Location().x);
-
1349  d3d_light.Direction.y = (float) (-light->Location().y);
-
1350  d3d_light.Direction.z = (float) (-light->Location().z);
-
1351 
-
1352  if (d3d_light.Direction.x == 0 &&
-
1353  d3d_light.Direction.y == 0 &&
-
1354  d3d_light.Direction.z == 0) {
-
1355 
-
1356  d3d_light.Direction.y = -1;
-
1357  }
-
1358 
-
1359  if (light->CastsShadow()) {
-
1360  if (!main_light || light->Intensity() > main_light->Intensity())
-
1361  main_light = light;
-
1362  }
-
1363  else if (!back_light) {
-
1364  back_light = light;
-
1365  }
-
1366  }
-
1367  else {
-
1368  d3d_light.Position.x = (float) ( light->Location().x);
-
1369  d3d_light.Position.y = (float) ( light->Location().y);
-
1370  d3d_light.Position.z = (float) ( light->Location().z);
-
1371  }
-
1372 
-
1373  float r = (light->GetColor().Red() / 255.0f) * light->Intensity();
-
1374  float g = (light->GetColor().Green() / 255.0f) * light->Intensity();
-
1375  float b = (light->GetColor().Blue() / 255.0f) * light->Intensity();
-
1376 
-
1377  d3d_light.Diffuse.r = r;
-
1378  d3d_light.Diffuse.g = g;
-
1379  d3d_light.Diffuse.b = b;
-
1380 
-
1381  d3d_light.Specular.r = r;
-
1382  d3d_light.Specular.g = g;
-
1383  d3d_light.Specular.b = b;
-
1384 
-
1385  d3d_light.Range = light->Intensity() * 10.0f;
-
1386  d3d_light.Attenuation0 = 0.1f;
-
1387  d3d_light.Attenuation1 = 0.7f;
-
1388  d3d_light.Attenuation2 = 0.0f;
-
1389 
-
1390  index++;
-
1391  d3ddevice->SetLight(index, &d3d_light);
-
1392  d3ddevice->LightEnable(index, TRUE);
-
1393  }
-
1394  }
-
1395 
-
1396  // turn off any unused lights from before:
-
1397  while (nlights > index+1) {
-
1398  d3ddevice->LightEnable(--nlights, FALSE);
-
1399  }
-
1400 
-
1401  nlights = index + 1;
-
1402 
-
1403  return true;
-
1404  }
-
1405 
-
1406  return false;
-
1407 }
-
1408 
-
1409 bool
-
1410 VideoDX9::SetCamera(const Camera* cam)
-
1411 {
-
1412  if (d3ddevice) {
-
1413  camera = cam;
-
1414 
-
1415  D3DMATRIX m;
-
1416  CreateD3DMatrix(m, cam->Orientation(), cam->Pos());
-
1417  d3ddevice->SetTransform(D3DTS_VIEW, &m);
-
1418  matrixView = m;
-
1419 
-
1420  return true;
-
1421  }
-
1422 
-
1423  return false;
-
1424 }
-
1425 
-
1426 bool
-
1427 VideoDX9::SetProjection(float fov, float znear, float zfar, DWORD type)
-
1428 {
-
1429  if (d3ddevice && zfar > znear) {
-
1430  D3DMATRIX m;
-
1431  float h, w, Q;
-
1432 
-
1433  double width = (float) (rect.w);
-
1434  double height = (float) (rect.h);
-
1435  ZeroMemory(&m, sizeof(m));
-
1436 
-
1437  /***
-
1438  *** PERSPECTIVE PROJECTION:
-
1439  ***/
-
1440 
-
1441  if (type == PROJECTION_PERSPECTIVE) {
-
1442  double xscale = width / fov;
-
1443  double yscale = height / fov;
-
1444 
-
1445  double maxscale = xscale;
-
1446  if (yscale > xscale) maxscale = yscale;
-
1447 
-
1448  double xangle = atan(fov/2 * maxscale/xscale);
-
1449 
-
1450  w = (float) (2/tan(xangle)); // 1/tan(x) == cot(x)
-
1451  h = (float) (w * width/height);
-
1452  Q = zfar/(zfar - znear);
-
1453 
-
1454  m._11 = w;
-
1455  m._22 = h;
-
1456  m._33 = Q;
-
1457  m._43 = -Q*znear;
-
1458  m._34 = 1;
-
1459  }
-
1460 
-
1461  /***
-
1462  *** ORTHOGONAL PROJECTION:
-
1463  ***/
-
1464 
-
1465  else if (type == PROJECTION_ORTHOGONAL) {
-
1466  m._11 = (float) (fov/width);
-
1467  m._22 = (float) (fov/height);
-
1468  m._33 = (float) (1/(zfar-znear));
-
1469  m._43 = (float) (znear/(znear-zfar));
-
1470  m._44 = (float) (1);
-
1471  }
-
1472 
-
1473  else {
-
1474  return false;
-
1475  }
-
1476 
-
1477  d3ddevice->SetTransform(D3DTS_PROJECTION, &m);
-
1478  matrixProj = m;
-
1479 
-
1480  return true;
-
1481  }
-
1482 
-
1483  return false;
-
1484 }
-
1485 
-
1486 // +--------------------------------------------------------------------+
-
1487 
-
1488 bool
-
1489 VideoDX9::SetEnvironment(Bitmap** faces)
-
1490 {
-
1491  if (environment_cube && !faces) {
-
1492  delete environment_cube;
-
1493  environment_cube = 0;
-
1494  return true;
-
1495  }
-
1496 
-
1497  if (!environment_cube) {
-
1498  environment_cube = new(__FILE__,__LINE__) TexCubeDX9(this);
-
1499  }
-
1500 
-
1501  if (environment_cube) {
-
1502  bool ok = true;
-
1503  for (int i = 0; i < 6; i++)
-
1504  ok = ok && environment_cube->LoadTexture(faces[i], i);
-
1505  return ok;
-
1506  }
-
1507 
-
1508  return false;
-
1509 }
-
1510 
-
1511 // +--------------------------------------------------------------------+
-
1512 
-
1513 bool
-
1514 VideoDX9::SetRenderState(RENDER_STATE state, DWORD value)
-
1515 {
-
1516  if (!d3ddevice)
-
1517  return false;
-
1518 
-
1519  if (render_state[state] == value || d3dstate_table[state] == 0) {
-
1520  render_state[state] = value;
-
1521  return true;
-
1522  }
-
1523 
-
1524  HRESULT hr = E_FAIL;
-
1525 
-
1526  // special case for texture wrapping:
-
1527  if (state == TEXTURE_WRAP) {
-
1528  DWORD wrap = D3DTADDRESS_CLAMP;
-
1529 
-
1530  if (value)
-
1531  wrap = D3DTADDRESS_WRAP;
-
1532 
-
1533  hr = d3ddevice->SetSamplerState(0, D3DSAMP_ADDRESSU, wrap);
-
1534  hr = d3ddevice->SetSamplerState(0, D3DSAMP_ADDRESSV, wrap);
-
1535  }
-
1536 
-
1537  // special case for fog enable:
-
1538  else if (state == FOG_ENABLE) {
-
1539  if (value) {
-
1540  hr = d3ddevice->SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_EXP);
-
1541  hr = d3ddevice->SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE);
-
1542  }
-
1543 
-
1544  hr = d3ddevice->SetRenderState(D3DRS_FOGENABLE, value);
-
1545  }
-
1546 
-
1547  // special case for z bias
-
1548  else if (state == Z_BIAS) {
-
1549  if (value) {
-
1550  FLOAT bias_scale = 1.0f;
-
1551  FLOAT depth_bias = (FLOAT) (DW2I(value) / -10000.0);
-
1552 
-
1553  hr = d3ddevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, F2DW(bias_scale));
-
1554  hr = d3ddevice->SetRenderState(D3DRS_DEPTHBIAS, F2DW(depth_bias));
-
1555  }
-
1556  else {
-
1557  hr = d3ddevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0);
-
1558  hr = d3ddevice->SetRenderState(D3DRS_DEPTHBIAS, 0);
-
1559  }
-
1560  }
-
1561 
-
1562  // set default z func along with z enable
-
1563  else if (state == Z_ENABLE) {
-
1564  hr = d3ddevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
-
1565  hr = d3ddevice->SetRenderState(D3DRS_ZENABLE, value);
-
1566  }
-
1567 
-
1568  // all other render states:
-
1569  else {
-
1570  hr = d3ddevice->SetRenderState((D3DRENDERSTATETYPE) d3dstate_table[state], value);
-
1571  }
-
1572 
-
1573  if (FAILED(hr)) {
-
1574  VideoDX9Error("could not SetRenderState", hr);
-
1575  return false;
-
1576  }
-
1577  else {
-
1578  render_state[state] = value;
-
1579  }
-
1580 
-
1581  return true;
-
1582 }
-
1583 
-
1584 bool
-
1585 VideoDX9::SetBlendType(int blend_type)
-
1586 {
-
1587  if (blend_type == current_blend_state)
-
1588  return true;
-
1589 
-
1590  switch (blend_type) {
-
1591  default:
-
1592  // map misc blend types to SOLID
-
1593  // and fall through to that case
-
1594 
-
1595  blend_type = BLEND_SOLID;
-
1596 
-
1597  case BLEND_SOLID:
-
1598  d3ddevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
-
1599  break;
-
1600 
-
1601  case BLEND_ALPHA:
-
1602  d3ddevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
-
1603  d3ddevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
-
1604  d3ddevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
-
1605  break;
-
1606 
-
1607  case BLEND_ADDITIVE:
-
1608  d3ddevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
-
1609  d3ddevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
-
1610  d3ddevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
-
1611  break;
-
1612  }
-
1613 
-
1614  current_blend_state = blend_type;
-
1615  return true;
-
1616 }
-
1617 
-
1618 // +--------------------------------------------------------------------+
-
1619 
-
1620 bool
-
1621 VideoDX9::StartFrame()
-
1622 {
-
1623  if (device_lost) {
-
1624  RecoverSurfaces();
-
1625 
-
1626  if (status != VIDEO_OK)
-
1627  return false;
-
1628  }
-
1629 
-
1630  stats.Clear();
-
1631 
-
1632  HRESULT err = 0;
-
1633  static int frame_number = 1;
-
1634  static int report_errs = 100;
-
1635 
-
1636  stats.nframe = frame_number;
-
1637  texcache->FrameNumber(frame_number++);
-
1638 
-
1639  // update gamma ramp for global fade value:
-
1640  SetGammaLevel(gamma);
-
1641 
-
1642  ClearAll();
-
1643 
-
1644  err = d3ddevice->BeginScene();
-
1645 
-
1646  if (FAILED(err)) {
-
1647  if (report_errs > 0) {
-
1648  report_errs--;
-
1649  VideoDX9Error("could not begin scene", err);
-
1650  }
-
1651 
-
1652  return false;
-
1653  }
-
1654 
-
1655  scene_active = 1;
-
1656  current_blend_state = -1;
-
1657 
-
1658  SetRenderState(LIGHTING_PASS, 0);
-
1659  SetRenderState(STENCIL_ENABLE, false);
-
1660 
-
1661  return true;
-
1662 }
-
1663 
-
1664 // +--------------------------------------------------------------------+
-
1665 
-
1666 bool
-
1667 VideoDX9::EndFrame()
-
1668 {
-
1669  HRESULT err = 0;
-
1670 
-
1671  if (scene_active) {
-
1672  err = d3ddevice->EndScene();
-
1673 
-
1674  if (FAILED(err)) {
-
1675  VideoDX9Error("could not end scene", err);
-
1676  return false;
-
1677  }
-
1678  }
-
1679 
-
1680  scene_active = 0;
-
1681  return true;
-
1682 }
-
1683 
-
1684 // +--------------------------------------------------------------------+
-
1685 
-
1686 static DWORD ColorModulate(DWORD a, DWORD b)
-
1687 {
-
1688  float a0 = (float) ((a ) & 0xff)/255.0f;
-
1689  float a1 = (float) ((a>> 8) & 0xff)/255.0f;
-
1690  float a2 = (float) ((a>>16) & 0xff)/255.0f;
-
1691  float a3 = (float) ((a>>24) & 0xff)/255.0f;
-
1692 
-
1693  float b0 = (float) ((b ) & 0xff)/255.0f;
-
1694  float b1 = (float) ((b>> 8) & 0xff)/255.0f;
-
1695  float b2 = (float) ((b>>16) & 0xff)/255.0f;
-
1696  float b3 = (float) ((b>>24) & 0xff)/255.0f;
-
1697 
-
1698  return (DWORD) ((BYTE)(a3*b3*255.0f) << 24) |
-
1699  ((BYTE)(a2*b2*255.0f) << 16) |
-
1700  ((BYTE)(a1*b1*255.0f) << 8) |
-
1701  ((BYTE)(a0*b0*255.0f));
-
1702 }
-
1703 
-
1704 // +--------------------------------------------------------------------+
-
1705 
-
1706 bool
-
1707 VideoDX9::PopulateScreenVerts(VertexSet* vset)
-
1708 {
-
1709  if (!vset || !screen_vbuf)
-
1710  return false;
-
1711 
-
1712  num_verts = vset->nverts;
-
1713 
-
1714  VideoDX9ScreenVertex* v = (VideoDX9ScreenVertex*) screen_vbuf->Lock(num_verts);
-
1715 
-
1716  if (v) {
-
1717  first_vert = screen_vbuf->GetNextVert();
-
1718 
-
1719  for (int i = 0; i < num_verts; i++) {
-
1720  v->sx = vset->s_loc[i].x;
-
1721  v->sy = vset->s_loc[i].y;
-
1722  v->sz = vset->s_loc[i].z;
-
1723  v->rhw = vset->rw[i];
-
1724 
-
1725  v->diffuse = vset->diffuse[i];
-
1726 
-
1727  v->tu = vset->tu[i];
-
1728  v->tv = vset->tv[i];
-
1729 
-
1730  v++;
-
1731  }
-
1732 
-
1733  screen_vbuf->Unlock();
-
1734  return true;
-
1735  }
-
1736 
-
1737  Print(" VideoDX9: could not lock screen vbuf for %d verts.\n", num_verts);
-
1738  return false;
-
1739 }
-
1740 
-
1741 // +--------------------------------------------------------------------+
-
1742 
-
1743 bool
-
1744 VideoDX9::DrawPolys(int npolys, Poly* polys)
-
1745 {
-
1746  bool result = false;
-
1747 
-
1748  if (d3ddevice && polys && npolys > 0) {
-
1749  // screen space polys:
-
1750  if (polys->vertex_set->space == VertexSet::SCREEN_SPACE)
-
1751  return DrawScreenPolys(npolys, polys);
-
1752 
-
1753  // world space polys:
-
1754  stats.ncalls++;
-
1755 
-
1756  VertexSet* vset = polys->vertex_set;
-
1757  int nverts = vset->nverts;
-
1758  bool luminous = false;
-
1759  bool detail = false;
-
1760  DWORD fvf = 0;
-
1761  void* verts = 0;
-
1762  int vsize = 0;
-
1763  WORD* indices = new(__FILE__,__LINE__) WORD[npolys*6];
-
1764 
-
1765  if (polys->material) {
-
1766  luminous = polys->material->luminous;
-
1767  }
-
1768 
-
1769  if (vset->tu1 != 0) {
-
1770  VideoDX9DetailVertex* v = new(__FILE__,__LINE__) VideoDX9DetailVertex[nverts];
-
1771  verts = v;
-
1772  vsize = sizeof(VideoDX9DetailVertex);
-
1773  fvf = VideoDX9DetailVertex::FVF;
-
1774 
-
1775  for (int i = 0; i < nverts; i++) {
-
1776  v->x = vset->loc[i].x;
-
1777  v->y = vset->loc[i].y;
-
1778  v->z = vset->loc[i].z;
-
1779 
-
1780  v->diffuse = vset->diffuse[i];
-
1781  v->specular = vset->specular[i];
-
1782 
-
1783  v->tu = vset->tu[i];
-
1784  v->tv = vset->tv[i];
-
1785  v->tu1 = vset->tu1[i];
-
1786  v->tv1 = vset->tv1[i];
-
1787 
-
1788  v++;
-
1789  }
-
1790  }
-
1791 
-
1792  else if (luminous) {
-
1793  VideoDX9LuminousVertex* v = new(__FILE__,__LINE__) VideoDX9LuminousVertex[nverts];
-
1794  verts = v;
-
1795  vsize = sizeof(VideoDX9LuminousVertex);
-
1796  fvf = VideoDX9LuminousVertex::FVF;
-
1797 
-
1798  for (int i = 0; i < nverts; i++) {
-
1799  v->x = vset->loc[i].x;
-
1800  v->y = vset->loc[i].y;
-
1801  v->z = vset->loc[i].z;
-
1802 
-
1803  v->diffuse = vset->diffuse[i];
-
1804 
-
1805  v->tu = vset->tu[i];
-
1806  v->tv = vset->tv[i];
-
1807 
-
1808  v++;
-
1809  }
-
1810  }
-
1811 
-
1812  else {
-
1813  VideoDX9SolidVertex* v = new(__FILE__,__LINE__) VideoDX9SolidVertex[nverts];
-
1814  verts = v;
-
1815  vsize = sizeof(VideoDX9SolidVertex);
-
1816  fvf = VideoDX9SolidVertex::FVF;
-
1817 
-
1818  for (int i = 0; i < nverts; i++) {
-
1819  v->x = vset->loc[i].x;
-
1820  v->y = vset->loc[i].y;
-
1821  v->z = vset->loc[i].z;
-
1822 
-
1823  v->nx = vset->nrm[i].x;
-
1824  v->ny = vset->nrm[i].y;
-
1825  v->nz = vset->nrm[i].z;
-
1826 
-
1827  v->tu = vset->tu[i];
-
1828  v->tv = vset->tv[i];
-
1829 
-
1830  v++;
-
1831  }
-
1832  }
-
1833 
-
1834  if (verts && indices) {
-
1835  HRESULT hr = E_FAIL;
-
1836 
-
1837  // fill index array
-
1838  int num_indices = 0;
-
1839  int num_tris = 0;
-
1840 
-
1841  WORD* s = indices;
-
1842  Poly* p = polys;
-
1843 
-
1844  for (int i = 0; i < npolys; i++) {
-
1845  if (p->nverts == 3) {
-
1846  num_indices += 3;
-
1847  num_tris += 1;
-
1848 
-
1849  *s++ = p->verts[0];
-
1850  *s++ = p->verts[1];
-
1851  *s++ = p->verts[2];
-
1852  }
-
1853 
-
1854  else if (p->nverts == 4) {
-
1855  num_indices += 6;
-
1856  num_tris += 2;
-
1857 
-
1858  *s++ = p->verts[0];
-
1859  *s++ = p->verts[1];
-
1860  *s++ = p->verts[2];
-
1861 
-
1862  *s++ = p->verts[0];
-
1863  *s++ = p->verts[2];
-
1864  *s++ = p->verts[3];
-
1865  }
-
1866 
-
1867  p++;
-
1868  }
-
1869 
-
1870  hr = d3ddevice->SetTransform(D3DTS_WORLD, &identity_matrix);
-
1871  hr = d3ddevice->SetVertexShader(NULL);
-
1872  hr = d3ddevice->SetFVF(fvf);
-
1873 
-
1874  // send primitives to the device
-
1875  Material* mtl = polys->material;
-
1876  IDirect3DTexture9* texture = 0;
-
1877 
-
1878  if (mtl && texcache && mtl->tex_diffuse) {
-
1879  texture = texcache->FindTexture(mtl->tex_diffuse);
-
1880  }
-
1881 
-
1882  if (current_texture != texture) {
-
1883  hr = d3ddevice->SetTexture(0, texture);
-
1884  current_texture = texture;
-
1885  }
-
1886 
-
1887  if (mtl && texcache && mtl->tex_detail) {
-
1888  texture = texcache->FindTexture(mtl->tex_detail);
-
1889  hr = d3ddevice->SetTexture(1, texture);
-
1890  }
-
1891 
-
1892  if (mtl && !luminous) {
-
1893  D3DMATERIAL9 d3dmtl;
-
1894  CreateD3DMaterial(d3dmtl, *mtl);
-
1895 
-
1896  hr = d3ddevice->SetMaterial(&d3dmtl);
-
1897  hr = d3ddevice->SetRenderState(D3DRS_AMBIENT, ambient.Value());
-
1898  }
-
1899 
-
1900  // set render states and select buffers
-
1901  SetRenderState(FILL_MODE, D3DFILL_SOLID);
-
1902  SetRenderState(LIGHTING_ENABLE, luminous ? FALSE : TRUE);
-
1903  SetBlendType(mtl->blend);
-
1904 
-
1905  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
-
1906  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
1907  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
-
1908  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
-
1909  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
1910  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
-
1911 
-
1912  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
-
1913 
-
1914 
-
1915  hr = d3ddevice->DrawIndexedPrimitiveUP(
-
1916  D3DPT_TRIANGLELIST,
-
1917  0,
-
1918  nverts,
-
1919  num_tris,
-
1920  indices,
-
1921  D3DFMT_INDEX16,
-
1922  verts,
-
1923  vsize);
-
1924 
-
1925  if (FAILED(hr)) {
-
1926  static int report = 10;
-
1927  if (report-- > 0)
-
1928  VideoDX9Error("Could not draw 3D polys.", hr);
-
1929  }
-
1930 
-
1931  delete [] verts;
-
1932  delete [] indices;
-
1933 
-
1934  if (SUCCEEDED(hr)) {
-
1935  stats.nverts += nverts;
-
1936  stats.npolys += num_tris;
-
1937  result = true;
-
1938  }
-
1939  }
-
1940  }
-
1941 
-
1942  return result;
-
1943 }
-
1944 
-
1945 // +--------------------------------------------------------------------+
-
1946 
-
1947 bool
-
1948 VideoDX9::DrawScreenPolys(int npolys, Poly* polys, int blend)
-
1949 {
-
1950  bool result = false;
-
1951  HRESULT hr = E_FAIL;
-
1952 
-
1953  if (d3ddevice && polys && npolys > 0 && screen_vbuf && screen_ibuf) {
-
1954  stats.ncalls++;
-
1955 
-
1956  // fill screen vertex buffer
-
1957  if (!PopulateScreenVerts(polys->vertex_set))
-
1958  return false;
-
1959 
-
1960  // fill screen index buffer
-
1961  int num_indices = 0;
-
1962  int num_tris = 0;
-
1963 
-
1964  // count the number of indices needed for these polys
-
1965  for (int i = 0; i < npolys; i++) {
-
1966  Poly* p = polys + i;
-
1967 
-
1968  if (p->nverts == 3) {
-
1969  num_indices += 3;
-
1970  num_tris += 1;
-
1971  }
-
1972 
-
1973  else if (p->nverts == 4) {
-
1974  num_indices += 6;
-
1975  num_tris += 2;
-
1976  }
-
1977  }
-
1978 
-
1979  WORD* screen_indices = screen_ibuf->Lock(num_indices);
-
1980  int first_index = screen_ibuf->GetNextIndex();
-
1981 
-
1982  if (!screen_indices) {
-
1983  Print(" VideoDX9: could not lock screen ibuf for %d indices.\n", num_indices);
-
1984  return false;
-
1985  }
-
1986 
-
1987  // copy the indices into the locked index buffer
-
1988  WORD* s = screen_indices;
-
1989  Poly* p = polys;
-
1990 
-
1991  for (int i = 0; i < npolys; i++) {
-
1992  if (p->nverts == 3) {
-
1993  *s++ = p->verts[0] + first_vert;
-
1994  *s++ = p->verts[1] + first_vert;
-
1995  *s++ = p->verts[2] + first_vert;
-
1996  }
-
1997  else if (p->nverts == 4) {
-
1998  *s++ = p->verts[0] + first_vert;
-
1999  *s++ = p->verts[1] + first_vert;
-
2000  *s++ = p->verts[2] + first_vert;
-
2001 
-
2002  *s++ = p->verts[0] + first_vert;
-
2003  *s++ = p->verts[2] + first_vert;
-
2004  *s++ = p->verts[3] + first_vert;
-
2005  }
-
2006 
-
2007  p++;
-
2008  }
-
2009 
-
2010  screen_ibuf->Unlock();
-
2011 
-
2012  // set render states and select buffers
-
2013  SetRenderState(FILL_MODE, D3DFILL_SOLID);
-
2014  SetRenderState(Z_ENABLE, D3DZB_FALSE);
-
2015  SetRenderState(Z_WRITE_ENABLE, D3DZB_FALSE);
-
2016  SetRenderState(LIGHTING_ENABLE, FALSE);
-
2017  SetBlendType(blend);
-
2018 
-
2019  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
-
2020  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
2021  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
-
2022  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
-
2023  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
2024  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
-
2025 
-
2026  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
-
2027 
-
2028  // send primitives to the device
-
2029  Material* mtl = polys->material;
-
2030  IDirect3DTexture9* texture = 0;
-
2031 
-
2032  if (mtl && texcache && mtl->tex_diffuse) {
-
2033  texture = texcache->FindTexture(mtl->tex_diffuse);
-
2034  }
-
2035 
-
2036  if (current_texture != texture) {
-
2037  hr = d3ddevice->SetTexture(0, texture);
-
2038  current_texture = texture;
-
2039  }
-
2040 
-
2041  screen_vbuf->Select(0);
-
2042  screen_ibuf->Select();
-
2043  hr = d3ddevice->SetVertexShader(NULL);
-
2044  hr = d3ddevice->SetFVF(VideoDX9ScreenVertex::FVF);
-
2045 
-
2046  hr = d3ddevice->DrawIndexedPrimitive(
-
2047  D3DPT_TRIANGLELIST,
-
2048  0,
-
2049  first_vert,
-
2050  num_verts,
-
2051  first_index,
-
2052  num_tris);
-
2053 
-
2054  if (FAILED(hr)) {
-
2055  static int report = 10;
-
2056  if (report-- > 0)
-
2057  VideoDX9Error("Could not draw screen polys.", hr);
-
2058  }
-
2059  else {
-
2060  stats.nverts += num_verts;
-
2061  stats.npolys += num_tris;
-
2062  result = true;
-
2063  }
-
2064  }
-
2065 
-
2066  return result;
-
2067 }
-
2068 
-
2069 // +--------------------------------------------------------------------+
-
2070 
-
2071 bool
-
2072 VideoDX9::DrawSolid(Solid* s, DWORD blend_modes)
-
2073 {
-
2074  bool result = false;
-
2075  HRESULT hr = E_FAIL;
-
2076 
-
2077  if (d3ddevice && s && s->GetModel()) {
-
2078  Model* model = s->GetModel();
-
2079  Matrix orient = s->Orientation();
-
2080  orient.Transpose();
-
2081 
-
2082  D3DMATRIX world_matrix;
-
2083  CreateD3DMatrix(world_matrix, orient, s->Location());
-
2084  d3ddevice->SetTransform(D3DTS_WORLD, &world_matrix);
-
2085  matrixWorld = world_matrix;
-
2086  D3DXMatrixInverse(&matrixWorldInverse, 0, &matrixWorld);
-
2087 
-
2088  ListIter<Surface> surf_iter = model->GetSurfaces();
-
2089  while (++surf_iter) {
-
2090  Surface* surf = surf_iter.value();
-
2091 
-
2092  if (surf->IsHidden() || surf->IsSimplified())
-
2093  continue;
-
2094 
-
2095  if (PrepareSurface(surf)) {
-
2096  result = true;
-
2097 
-
2098  VideoDX9SurfaceData* surf_data = (VideoDX9SurfaceData*) surf->GetVideoPrivateData();
-
2099  surf_data->vertex_buffer->Select(0);
-
2100  surf_data->index_buffer->Select();
-
2101 
-
2102  ListIter<Segment> seg_iter = surf->GetSegments();
-
2103  while (++seg_iter) {
-
2104  Segment* segment = seg_iter.value();
-
2105  Material* mtl = segment->material;
-
2106 
-
2107  if (mtl && (blend_modes & mtl->blend)) {
-
2108  result = result && DrawSegment(segment);
-
2109  }
-
2110  }
-
2111  }
-
2112  }
-
2113  }
-
2114 
-
2115  surface_has_tangent_data = false;
-
2116 
-
2117  return result;
-
2118 }
-
2119 
-
2120 bool
-
2121 VideoDX9::DrawSegment(Segment* segment)
-
2122 {
-
2123  bool result = false;
-
2124  bool detail = false;
-
2125  bool luminous = false;
-
2126  HRESULT hr = E_FAIL;
-
2127 
-
2128  if (segment && segment->video_data) {
-
2129  stats.ncalls++;
-
2130 
-
2131  VideoDX9SegmentData* seg_data = (VideoDX9SegmentData*) segment->video_data;
-
2132  int first_vert = seg_data->first_vert;
-
2133  int num_verts = seg_data->num_verts;
-
2134  int first_index = seg_data->first_index;
-
2135  int num_tris = seg_data->num_tris;
-
2136 
-
2137  if (segment->model)
-
2138  luminous = segment->model->IsLuminous();
-
2139 
-
2140  // set render states and select buffers
-
2141  d3ddevice->SetRenderState(D3DRS_AMBIENT, ambient.Value());
-
2142 
-
2143  Material* mtl = segment->material;
-
2144 
-
2145  if (use_material)
-
2146  mtl = use_material;
-
2147 
-
2148  if (segment->polys && segment->polys->vertex_set && segment->polys->vertex_set->tu1)
-
2149  detail = true;
-
2150 
-
2151  // send primitives to the device
-
2152  if (detail) {
-
2153  hr = d3ddevice->SetVertexShader(NULL);
-
2154  hr = d3ddevice->SetFVF(VideoDX9DetailVertex::FVF);
-
2155  }
-
2156 
-
2157  else if (luminous) {
-
2158  hr = d3ddevice->SetVertexShader(NULL);
-
2159  hr = d3ddevice->SetFVF(VideoDX9LuminousVertex::FVF);
-
2160  }
-
2161 
-
2162  else if (surface_has_tangent_data && vertex_declaration) {
-
2163  hr = d3ddevice->SetVertexDeclaration(vertex_declaration);
-
2164  hr = d3ddevice->SetVertexShader(NULL);
-
2165  }
-
2166 
-
2167  else {
-
2168  hr = d3ddevice->SetVertexShader(NULL);
-
2169  hr = d3ddevice->SetFVF(VideoDX9SolidVertex::FVF);
-
2170  }
-
2171 
-
2172  if (render_state[FILL_MODE] == FILL_WIREFRAME) {
-
2173  PrepareMaterial(mtl);
-
2174  SetupPass(0);
-
2175 
-
2176  for (int i = 0; i < segment->npolys; i++) {
-
2177  DrawPolyOutline(segment->polys + i);
-
2178  }
-
2179  }
-
2180 
-
2181  else if (luminous) {
-
2182  PrepareMaterial(mtl);
-
2183 
-
2184  SetRenderState(FILL_MODE, D3DFILL_SOLID);
-
2185  SetRenderState(LIGHTING_ENABLE, FALSE);
-
2186  SetBlendType(mtl->blend);
-
2187 
-
2188  for (int pass = 0; pass < passes; pass++) {
-
2189  SetupPass(pass);
-
2190 
-
2191  hr = d3ddevice->DrawIndexedPrimitive(
-
2192  D3DPT_TRIANGLELIST,
-
2193  0,
-
2194  first_vert,
-
2195  num_verts,
-
2196  first_index,
-
2197  num_tris);
-
2198  }
-
2199 
-
2200  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
-
2201  }
-
2202 
-
2203  else {
-
2204  PrepareMaterial(mtl);
-
2205 
-
2206  if (strategy == DX9_STRATEGY_GLOW && render_state[LIGHTING_PASS] > 0) {
-
2207  hr = 0;
-
2208  }
-
2209 
-
2210  else if (magic_fx && strategy < DX9_STRATEGY_BLEND && !detail) {
-
2211  DWORD vs_version = 0;
-
2212  DWORD ps_version = 0;
-
2213  bool shaders_ok = false;
-
2214 
-
2215  VideoDX9DeviceInfo* dev_info = dx9enum->GetDeviceInfo(video_settings.GetDeviceType());
-
2216 
-
2217  if (dev_info) {
-
2218  vs_version = video_settings.enable_vs ? dev_info->caps.VertexShaderVersion : 0;
-
2219  ps_version = video_settings.enable_ps ? dev_info->caps.PixelShaderVersion : 0;
-
2220 
-
2221  if (vs_version >= D3DVS_VERSION(1,1))
-
2222  shaders_ok = true;
-
2223  }
-
2224 
-
2225  if (surface_has_tangent_data && vertex_declaration) {
-
2226  hr = d3ddevice->SetVertexShader(NULL);
-
2227  hr = d3ddevice->SetVertexDeclaration(vertex_declaration);
-
2228  }
-
2229 
-
2230  else {
-
2231  hr = d3ddevice->SetVertexShader(NULL);
-
2232  hr = d3ddevice->SetFVF(VideoDX9SolidVertex::FVF);
-
2233  }
-
2234 
-
2235  bool would_bump = !IsBumpMapEnabled() && mtl->bump > 0.5;
-
2236 
-
2237  bool will_bump = IsBumpMapEnabled() && surface_has_tangent_data && shaders_ok && camera;
-
2238 
-
2239  bool do_pix = will_bump && render_state[LIGHTING_PASS] == 0;
-
2240  bool do_bump = will_bump && render_state[LIGHTING_PASS] > 0;
-
2241 
-
2242  D3DXMATRIX matrixWVP = matrixWorld * matrixView * matrixProj;
-
2243 
-
2244  D3DXVECTOR4 eyePos( (float) camera->Pos().x, (float) camera->Pos().y, (float) camera->Pos().z, 1.0f);
-
2245 
-
2246  D3DXVECTOR4 eyeObj;
-
2247  D3DXVec4Transform(&eyeObj, &eyePos, &matrixWorldInverse);
-
2248 
-
2249  D3DXVECTOR4 lightPos(100.0f, 100.0f, 100.0f, 1.0f);
-
2250  D3DXVECTOR4 lightColor(1,1,1,1);
-
2251  D3DXVECTOR4 ambientColor(0,0,0,1);
-
2252 
-
2253  ambientColor.x = ambient.fRed();
-
2254  ambientColor.y = ambient.fGreen();
-
2255  ambientColor.z = ambient.fBlue();
-
2256 
-
2257  if (main_light && (render_state[LIGHTING_PASS] > 0 || mtl->blend > Material::MTL_SOLID)) {
-
2258  lightPos.x = (float) main_light->Location().x;
-
2259  lightPos.y = (float) main_light->Location().y;
-
2260  lightPos.z = (float) main_light->Location().z;
-
2261 
-
2262  if (mtl->tex_bumpmap && do_bump)
-
2263  D3DXVec4Transform(&lightPos, &lightPos, &matrixWorldInverse);
-
2264 
-
2265  lightColor.x = main_light->GetColor().fRed() * main_light->Intensity();
-
2266  lightColor.y = main_light->GetColor().fGreen() * main_light->Intensity();
-
2267  lightColor.z = main_light->GetColor().fBlue() * main_light->Intensity();
-
2268  lightColor.w = 1.0f;
-
2269  }
-
2270 
-
2271  else if (back_light && render_state[LIGHTING_PASS] == 0) {
-
2272  lightPos.x = (float) back_light->Location().x;
-
2273  lightPos.y = (float) back_light->Location().y;
-
2274  lightPos.z = (float) back_light->Location().z;
-
2275 
-
2276  lightColor.x = back_light->GetColor().fRed() * back_light->Intensity();
-
2277  lightColor.y = back_light->GetColor().fGreen() * back_light->Intensity();
-
2278  lightColor.z = back_light->GetColor().fBlue() * back_light->Intensity();
-
2279  lightColor.w = 1.0f;
-
2280  }
-
2281 
-
2282  D3DXVECTOR4 lightDir = D3DXVECTOR4(0.0f, 0.0f, 0.0f, 0.0f) - lightPos;
-
2283  D3DXVec4Normalize(&lightDir, &lightDir);
-
2284 
-
2285  magic_fx->SetMatrix("wvp", &matrixWVP);
-
2286  magic_fx->SetMatrix("world", &matrixWorld);
-
2287  magic_fx->SetMatrix("view", &matrixView);
-
2288  magic_fx->SetMatrix("proj", &matrixProj);
-
2289  magic_fx->SetMatrix("worldInv", &matrixWorldInverse);
-
2290 
-
2291  magic_fx->SetVector("light1Pos", &lightPos);
-
2292  magic_fx->SetVector("light1Dir", &lightDir);
-
2293  magic_fx->SetVector("light1Color", &lightColor);
-
2294  magic_fx->SetVector("ambientColor", &ambientColor);
-
2295  magic_fx->SetVector("eyeObj", &eyeObj);
-
2296 
-
2297  FLOAT base_bias = (FLOAT) (DW2I(render_state[Z_BIAS]) / -10000.0);
-
2298  magic_fx->SetFloat("bias", base_bias + video_settings.depth_bias);
-
2299 
-
2300  ColorValue orig_ks = mtl->Ks;
-
2301 
-
2302  if (would_bump && mtl->specular_value >= 0.5)
-
2303  mtl->Ks = mtl->Ks * 0.3;
-
2304 
-
2305  magic_fx->SetValue("Ka", &mtl->Ka, sizeof(ColorValue));
-
2306  magic_fx->SetValue("Kd", &mtl->Kd, sizeof(ColorValue));
-
2307  magic_fx->SetValue("Ke", &mtl->Ke, sizeof(ColorValue));
-
2308  magic_fx->SetValue("Ks", &mtl->Ks, sizeof(ColorValue));
-
2309  magic_fx->SetFloat("Ns", mtl->power);
-
2310 
-
2311  if (would_bump && mtl->specular_value >= 0.5)
-
2312  mtl->Ks = orig_ks;
-
2313 
-
2314  if (mtl->tex_diffuse) {
-
2315  IDirect3DTexture9* texture = texcache->FindTexture(mtl->tex_diffuse);
-
2316  magic_fx->SetTexture("tex_d", texture);
-
2317  } else {
-
2318  magic_fx->SetTexture("tex_d", 0);
-
2319  }
-
2320 
-
2321  if (mtl->tex_emissive) {
-
2322  IDirect3DTexture9* texture = texcache->FindTexture(mtl->tex_emissive);
-
2323  magic_fx->SetTexture("tex_e", texture);
-
2324  } else {
-
2325  magic_fx->SetTexture("tex_e", 0);
-
2326  }
-
2327 
-
2328  if (mtl->tex_specular && IsSpecMapEnabled()) {
-
2329  IDirect3DTexture9* texture = texcache->FindTexture(mtl->tex_specular);
-
2330  magic_fx->SetTexture("tex_s", texture);
-
2331  } else {
-
2332  magic_fx->SetTexture("tex_s", 0);
-
2333  }
-
2334 
-
2335  if (mtl->tex_bumpmap && do_bump) {
-
2336  IDirect3DTexture9* texture = texcache->FindNormalMap(mtl->tex_bumpmap, mtl->bump);
-
2337  magic_fx->SetTexture("tex_n", texture);
-
2338  magic_fx->SetFloat("offsetAmp", mtl->bump / mtl->tex_bumpmap->Height());
-
2339  } else if (mtl->tex_bumpmap && !do_bump) {
-
2340  IDirect3DTexture9* texture = texcache->FindTexture(mtl->tex_bumpmap);
-
2341  magic_fx->SetTexture("tex_x", texture);
-
2342  } else {
-
2343  magic_fx->SetTexture("tex_x", 0);
-
2344  }
-
2345 
-
2346  const char* mtl_shader = mtl->GetShader(render_state[LIGHTING_PASS]);
-
2347  D3DXHANDLE hnd_shader = 0;
-
2348 
-
2349  if (mtl_shader) {
-
2350  if (!strcmp(mtl_shader, "null"))
-
2351  return true;
-
2352 
-
2353  hnd_shader = magic_fx->GetTechniqueByName(mtl_shader);
-
2354  }
-
2355 
-
2356  if (hnd_shader) {
-
2357  hr = magic_fx->SetTechnique(hnd_shader);
-
2358  } else {
-
2359  if (will_bump) {
-
2360  if (mtl->tex_specular && IsSpecMapEnabled()) {
-
2361  if (mtl->tex_bumpmap && do_bump) {
-
2362  if (ps_version >= D3DPS_VERSION(2,0))
-
2363  hr = magic_fx->SetTechnique("BumpSpecMapPix");
-
2364  else
-
2365  hr = magic_fx->SetTechnique("BumpSpecMap");
-
2366  } else if (mtl->tex_emissive && render_state[LIGHTING_PASS] == 0) {
-
2367  if (ps_version >= D3DPS_VERSION(2,0))
-
2368  hr = magic_fx->SetTechnique("EmissiveSpecMapPix");
-
2369  else
-
2370  hr = magic_fx->SetTechnique("EmissiveSpecularTexture");
-
2371  } else {
-
2372  if (ps_version >= D3DPS_VERSION(2,0))
-
2373  hr = magic_fx->SetTechnique("SpecMapPix");
-
2374  else
-
2375  hr = magic_fx->SetTechnique("SpecularTexture");
-
2376  }
-
2377  } else {
-
2378  if (mtl->tex_bumpmap && do_bump) {
-
2379  if (ps_version >= D3DPS_VERSION(2,0))
-
2380  hr = magic_fx->SetTechnique("BumpMapPix");
-
2381  else
-
2382  hr = magic_fx->SetTechnique("BumpMap");
-
2383  } else if (mtl->tex_emissive && render_state[LIGHTING_PASS] == 0) {
-
2384  if (ps_version >= D3DPS_VERSION(2,0))
-
2385  hr = magic_fx->SetTechnique("EmissivePix");
-
2386  else
-
2387  hr = magic_fx->SetTechnique("EmissiveTexture");
-
2388  } else {
-
2389  if (ps_version >= D3DPS_VERSION(2,0))
-
2390  hr = magic_fx->SetTechnique("SimplePix");
-
2391  else
-
2392  hr = magic_fx->SetTechnique("SimpleTexture");
-
2393  }
-
2394  }
-
2395  }
-
2396 
-
2397  else if (texcache && mtl->tex_diffuse) {
-
2398  if (mtl->tex_specular && IsSpecMapEnabled()) {
-
2399  if (mtl->tex_emissive && render_state[LIGHTING_PASS] == 0) {
-
2400  hr = magic_fx->SetTechnique("EmissiveSpecularTexture");
-
2401  } else {
-
2402  hr = magic_fx->SetTechnique("SpecularTexture");
-
2403  }
-
2404  }
-
2405 
-
2406  else {
-
2407  if (mtl->tex_emissive && render_state[LIGHTING_PASS] == 0) {
-
2408  hr = magic_fx->SetTechnique("EmissiveTexture");
-
2409  } else {
-
2410  hr = magic_fx->SetTechnique("SimpleTexture");
-
2411  }
-
2412  }
-
2413  } else {
-
2414  hr = magic_fx->SetTechnique("SimpleMaterial");
-
2415  }
-
2416  }
-
2417 
-
2418  if (environment_cube != 0 && magic_fx->IsParameterUsed("env_cube", hnd_shader)) {
-
2419  D3DXMATRIX env_matrix;
-
2420  D3DXMatrixIdentity(&env_matrix);
-
2421 
-
2422  magic_fx->SetMatrix("env_matrix", &env_matrix);
-
2423  magic_fx->SetTexture("env_cube", environment_cube->GetTexture());
-
2424  }
-
2425 
-
2426  if (render_state[STENCIL_ENABLE]) {
-
2427  d3ddevice->SetRenderState(D3DRS_STENCILENABLE, TRUE);
-
2428  d3ddevice->SetRenderState(D3DRS_STENCILREF, 0x01);
-
2429  d3ddevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_GREATER);
-
2430  } else {
-
2431  d3ddevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
-
2432  }
-
2433 
-
2434  if (render_state[LIGHTING_PASS] > 0) {
-
2435  current_blend_state = 100;
-
2436  SetBlendType(BLEND_ADDITIVE);
-
2437  SetRenderState(Z_WRITE_ENABLE, FALSE);
-
2438  } else {
-
2439  current_blend_state = 100;
-
2440  SetBlendType(mtl->blend);
-
2441  }
-
2442 
-
2443  UINT nPasses = 0;
-
2444 
-
2445  hr = magic_fx->Begin(&nPasses, 0);
-
2446 
-
2447  for (UINT i = 0; i < nPasses; i++) {
-
2448  hr = magic_fx->BeginPass(i);
-
2449 
-
2450  hr = d3ddevice->DrawIndexedPrimitive(
-
2451  D3DPT_TRIANGLELIST,
-
2452  0,
-
2453  first_vert,
-
2454  num_verts,
-
2455  first_index,
-
2456  num_tris);
-
2457 
-
2458  hr = magic_fx->EndPass();
-
2459  }
-
2460 
-
2461  hr = magic_fx->End();
-
2462  } else {
-
2463  for (int pass = 0; pass < passes; pass++) {
-
2464  SetupPass(pass);
-
2465 
-
2466  hr = d3ddevice->DrawIndexedPrimitive(
-
2467  D3DPT_TRIANGLELIST,
-
2468  0,
-
2469  first_vert,
-
2470  num_verts,
-
2471  first_index,
-
2472  num_tris);
-
2473 
-
2474  if (detail) {
-
2475  hr = d3ddevice->SetVertexShader(NULL);
-
2476  hr = d3ddevice->SetFVF(VideoDX9DetailVertex::FVF);
-
2477  } else if (luminous) {
-
2478  hr = d3ddevice->SetVertexShader(NULL);
-
2479  hr = d3ddevice->SetFVF(VideoDX9LuminousVertex::FVF);
-
2480  } else if (surface_has_tangent_data && vertex_declaration) {
-
2481  hr = d3ddevice->SetVertexShader(NULL);
-
2482  hr = d3ddevice->SetVertexDeclaration(vertex_declaration);
-
2483  } else {
-
2484  hr = d3ddevice->SetVertexShader(NULL);
-
2485  hr = d3ddevice->SetFVF(VideoDX9SolidVertex::FVF);
-
2486  }
-
2487  }
-
2488  }
-
2489  }
-
2490 
-
2491  if (FAILED(hr)) {
-
2492  static int report = 10;
-
2493  if (report-- > 0)
-
2494  VideoDX9Error("Could not draw solid polys.", hr);
-
2495  } else {
-
2496  stats.nverts += num_verts;
-
2497  stats.npolys += num_tris;
-
2498  result = true;
-
2499  }
-
2500  }
-
2501 
-
2502  return result;
-
2503 }
-
2504 
-
2505 bool
-
2506 VideoDX9::DrawPolyOutline(Poly* p)
-
2507 {
-
2508  if (d3ddevice && p && p->nverts >= 3) {
-
2509  static VideoDX9LineVertex verts[8];
-
2510 
-
2511  int nlines = p->nverts;
-
2512  VertexSet* vset = p->vertex_set;
-
2513  WORD index = 0;
-
2514  Color color = Color::Black;
-
2515  HRESULT hr = E_FAIL;
-
2516 
-
2517  ZeroMemory(verts, sizeof(verts));
-
2518 
-
2519  if (p->material)
-
2520  color = p->material->Kd.ToColor();
-
2521 
-
2522  for (int i = 0; i < p->nverts; i++) {
-
2523  index = p->verts[i];
-
2524 
-
2525  verts[i].x = vset->loc[index].x;
-
2526  verts[i].y = vset->loc[index].y;
-
2527  verts[i].z = vset->loc[index].z;
-
2528  verts[i].diffuse = color.Value();
-
2529  }
-
2530 
-
2531  // last vertex, to close the loop
-
2532  index = p->verts[0];
-
2533  int i = p->nverts;
-
2534 
-
2535  verts[i].x = vset->loc[index].x;
-
2536  verts[i].y = vset->loc[index].y;
-
2537  verts[i].z = vset->loc[index].z;
-
2538  verts[i].diffuse = color.Value();
-
2539 
-
2540  current_texture = 0;
-
2541 
-
2542  hr = d3ddevice->SetVertexShader(NULL);
-
2543  hr = d3ddevice->SetFVF(VideoDX9LineVertex::FVF);
-
2544  hr = d3ddevice->SetTexture(0, 0);
-
2545  hr = d3ddevice->DrawPrimitiveUP(
-
2546  D3DPT_LINESTRIP,
-
2547  nlines,
-
2548  verts,
-
2549  sizeof(VideoDX9LineVertex));
-
2550  return true;
-
2551  }
-
2552 
-
2553  return false;
-
2554 }
-
2555 
-
2556 // +--------------------------------------------------------------------+
-
2557 
-
2558 bool
-
2559 VideoDX9::DrawShadow(Solid* s, int nverts, Vec3* shadow_verts, bool visible)
-
2560 {
-
2561  bool result = false;
-
2562  HRESULT hr = E_FAIL;
-
2563 
-
2564  if (d3ddevice && s && nverts && shadow_verts && IsShadowEnabled()) {
-
2565  Matrix orient = s->Orientation();
-
2566  orient.Transpose();
-
2567 
-
2568  D3DMATRIX world_matrix;
-
2569  CreateD3DMatrix(world_matrix, orient, s->Location());
-
2570  d3ddevice->SetTransform(D3DTS_WORLD, &world_matrix);
-
2571  matrixWorld = world_matrix;
-
2572 
-
2573  // show shadow outlines:
-
2574  if (visible) {
-
2575  static VideoDX9LineVertex verts[4];
-
2576 
-
2577  d3ddevice->SetRenderState(D3DRS_ZENABLE, TRUE);
-
2578  d3ddevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
-
2579  d3ddevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
-
2580  d3ddevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);
-
2581  d3ddevice->SetRenderState(D3DRS_LIGHTING, FALSE);
-
2582  d3ddevice->SetVertexShader(NULL);
-
2583  d3ddevice->SetFVF(VideoDX9LineVertex::FVF);
-
2584  d3ddevice->SetTexture(0, 0);
-
2585 
-
2586  SetBlendType(BLEND_ALPHA);
-
2587 
-
2588  for (int i = 0; i < nverts; i+=3) {
-
2589  DWORD c = 0xa0ffff80;
-
2590 
-
2591  verts[0].x = shadow_verts[i+0].x;
-
2592  verts[0].y = shadow_verts[i+0].y;
-
2593  verts[0].z = shadow_verts[i+0].z;
-
2594  verts[0].diffuse = c;
-
2595 
-
2596  verts[1].x = shadow_verts[i+1].x;
-
2597  verts[1].y = shadow_verts[i+1].y;
-
2598  verts[1].z = shadow_verts[i+1].z;
-
2599  verts[1].diffuse = c;
-
2600 
-
2601  verts[2].x = shadow_verts[i+2].x;
-
2602  verts[2].y = shadow_verts[i+2].y;
-
2603  verts[2].z = shadow_verts[i+2].z;
-
2604  verts[2].diffuse = c;
-
2605 
-
2606  verts[3].x = shadow_verts[i+0].x;
-
2607  verts[3].y = shadow_verts[i+0].y;
-
2608  verts[3].z = shadow_verts[i+0].z;
-
2609  verts[3].diffuse = c;
-
2610 
-
2611  hr = d3ddevice->DrawPrimitiveUP(
-
2612  D3DPT_LINESTRIP,
-
2613  3,
-
2614  verts,
-
2615  sizeof(VideoDX9LineVertex));
-
2616  }
-
2617 
-
2618  // restore lighting state
-
2619  d3ddevice->SetRenderState(D3DRS_LIGHTING, render_state[LIGHTING_ENABLE]);
-
2620  }
-
2621 
-
2622  // render shadows into stencil buffer:
-
2623 
-
2624  // Disable z-buffer writes (note: z-testing still occurs), and enable the
-
2625  // stencil-buffer
-
2626  d3ddevice->SetRenderState(D3DRS_ZENABLE, TRUE);
-
2627  d3ddevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
-
2628  d3ddevice->SetRenderState(D3DRS_STENCILENABLE, TRUE);
-
2629 
-
2630  // Dont bother with interpolating color
-
2631  d3ddevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);
-
2632 
-
2633  // Set up stencil compare fuction, reference value, and masks.
-
2634  // Stencil test passes if ((ref & mask) cmpfn (stencil & mask)) is true.
-
2635  // Note: since we set up the stencil-test to always pass, the STENCILFAIL
-
2636  // renderstate is really not needed.
-
2637  d3ddevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS );
-
2638  d3ddevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP );
-
2639  d3ddevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP );
-
2640 
-
2641  // If z-test passes, inc/decrement stencil buffer value
-
2642  d3ddevice->SetRenderState(D3DRS_STENCILREF, 0x1 );
-
2643  d3ddevice->SetRenderState(D3DRS_STENCILMASK, 0xff );
-
2644  d3ddevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xff );
-
2645  d3ddevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_INCR );
-
2646 
-
2647  // Make sure that no pixels get drawn to the frame buffer
-
2648  d3ddevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE );
-
2649  d3ddevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ZERO );
-
2650  d3ddevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE );
-
2651 
-
2652  d3ddevice->SetVertexShader(NULL);
-
2653  d3ddevice->SetFVF(D3DFVF_XYZ);
-
2654 
-
2655  // Draw front-side of shadow volume in stencil/z only
-
2656  hr = d3ddevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nverts/3, shadow_verts, sizeof(Vec3));
-
2657 
-
2658  // Now reverse cull order so back sides of shadow volume are written.
-
2659  d3ddevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW );
-
2660 
-
2661  // Decrement stencil buffer value
-
2662  d3ddevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_DECR );
-
2663 
-
2664  // Draw back-side of shadow volume in stencil/z only
-
2665  hr = d3ddevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nverts/3, shadow_verts, sizeof(Vec3));
-
2666 
-
2667  // restore render states
-
2668  d3ddevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
-
2669  d3ddevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
-
2670  d3ddevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
-
2671  d3ddevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
-
2672 
-
2673  // force restore of current blend type
-
2674  int type = current_blend_state;
-
2675  current_blend_state = 100;
-
2676  SetBlendType(type);
-
2677 
-
2678  result = SUCCEEDED(hr);
-
2679  }
-
2680 
-
2681  return result;
-
2682 }
-
2683 
-
2684 // +--------------------------------------------------------------------+
-
2685 
-
2686 bool
-
2687 VideoDX9::DrawLines(int nlines, Vec3* points, Color c, int blend)
-
2688 {
-
2689  bool result = false;
-
2690 
-
2691  if (d3ddevice && points && nlines > 0 && nlines <= 256) {
-
2692  stats.ncalls++;
-
2693 
-
2694  VideoDX9LineVertex* verts = line_verts;
-
2695 
-
2696  if (verts) {
-
2697  HRESULT hr = E_FAIL;
-
2698 
-
2699  for (int i = 0; i < 2*nlines; i++) {
-
2700  VideoDX9LineVertex* v = verts + i;
-
2701  Vec3* p = points + i;
-
2702 
-
2703  v->x = p->x;
-
2704  v->y = p->y;
-
2705  v->z = p->z;
-
2706  v->diffuse = c.Value();
-
2707  }
-
2708 
-
2709  hr = d3ddevice->SetTransform(D3DTS_WORLD, &identity_matrix);
-
2710  hr = d3ddevice->SetVertexShader(NULL);
-
2711  hr = d3ddevice->SetFVF(VideoDX9LineVertex::FVF);
-
2712 
-
2713  DWORD old_lighting = render_state[LIGHTING_ENABLE];
-
2714 
-
2715  // untextured lines:
-
2716  if (current_texture) {
-
2717  d3ddevice->SetTexture(0, 0);
-
2718  current_texture = 0;
-
2719  }
-
2720 
-
2721  SetRenderState(LIGHTING_ENABLE, FALSE);
-
2722  SetBlendType(blend);
-
2723 
-
2724  hr = d3ddevice->DrawPrimitiveUP(
-
2725  D3DPT_LINELIST,
-
2726  nlines,
-
2727  verts,
-
2728  sizeof(VideoDX9LineVertex));
-
2729 
-
2730  if (FAILED(hr)) {
-
2731  static int report = 10;
-
2732  if (report-- > 0)
-
2733  VideoDX9Error("Could not draw 3D lines.", hr);
-
2734  }
-
2735 
-
2736  SetRenderState(LIGHTING_ENABLE, old_lighting);
-
2737 
-
2738  if (SUCCEEDED(hr)) {
-
2739  stats.nverts += 2*nlines;
-
2740  stats.nlines += nlines;
-
2741  result = true;
-
2742  }
-
2743  }
-
2744  }
-
2745 
-
2746  return result;
-
2747 }
-
2748 
-
2749 // +--------------------------------------------------------------------+
-
2750 
-
2751 bool
-
2752 VideoDX9::DrawScreenLines(int nlines, float* points, Color c, int blend)
-
2753 {
-
2754  bool result = false;
-
2755 
-
2756  if (d3ddevice && points && nlines > 0 && nlines <= 64) {
-
2757  stats.ncalls++;
-
2758 
-
2759  VideoDX9ScreenVertex* verts = screen_line_verts;
-
2760 
-
2761  if (verts) {
-
2762  HRESULT hr = E_FAIL;
-
2763 
-
2764  for (int i = 0; i < 2*nlines; i++) {
-
2765  VideoDX9ScreenVertex* v = verts + i;
-
2766 
-
2767  v->sx = points[2*i + 0];
-
2768  v->sy = points[2*i + 1];
-
2769  v->sz = 0.0f;
-
2770  v->rhw = 1.0f;
-
2771  v->diffuse = c.Value();
-
2772  v->tu = 0.0f;
-
2773  v->tv = 0.0f;
-
2774  }
-
2775 
-
2776  hr = d3ddevice->SetVertexShader(NULL);
-
2777  hr = d3ddevice->SetFVF(VideoDX9ScreenVertex::FVF);
-
2778 
-
2779  if (FAILED(hr)) {
-
2780  static int report = 10;
-
2781  if (report-- > 0)
-
2782  VideoDX9Error("Could not set FVF for screen lines.", hr);
-
2783  }
-
2784 
-
2785  else {
-
2786  if (current_texture != 0) {
-
2787  hr = d3ddevice->SetTexture(0, 0);
-
2788  current_texture = 0;
-
2789  }
-
2790 
-
2791  SetRenderState(FILL_MODE, D3DFILL_SOLID);
-
2792  SetRenderState(Z_ENABLE, D3DZB_FALSE);
-
2793  SetRenderState(LIGHTING_ENABLE, FALSE);
-
2794  SetBlendType(blend);
-
2795 
-
2796  hr = d3ddevice->DrawPrimitiveUP(
-
2797  D3DPT_LINELIST,
-
2798  nlines,
-
2799  verts,
-
2800  sizeof(VideoDX9ScreenVertex));
-
2801 
-
2802  if (FAILED(hr)) {
-
2803  static int report = 10;
-
2804  if (report-- > 0)
-
2805  VideoDX9Error("Could not draw screen lines.", hr);
-
2806  }
-
2807  }
-
2808 
-
2809  if (SUCCEEDED(hr)) {
-
2810  stats.nverts += 2*nlines;
-
2811  stats.nlines += nlines;
-
2812  result = true;
-
2813  }
-
2814  }
-
2815  }
-
2816 
-
2817  return result;
-
2818 }
-
2819 
-
2820 // +--------------------------------------------------------------------+
-
2821 
-
2822 bool
-
2823 VideoDX9::DrawPoints(VertexSet* vset)
-
2824 {
-
2825  if (vset && vset->nverts) {
-
2826  HRESULT hr = E_FAIL;
-
2827 
-
2828  int nverts = vset->nverts;
-
2829  VideoDX9LineVertex* verts = new(__FILE__,__LINE__) VideoDX9LineVertex[nverts];
-
2830 
-
2831  if (verts) {
-
2832  for (int i = 0; i < nverts; i++) {
-
2833  VideoDX9LineVertex* v = verts + i;
-
2834  Vec3* p = vset->loc + i;
-
2835 
-
2836  v->x = p->x;
-
2837  v->y = p->y;
-
2838  v->z = p->z;
-
2839  v->diffuse = vset->diffuse[i];
-
2840  }
-
2841 
-
2842  SetRenderState(LIGHTING_ENABLE, FALSE);
-
2843 
-
2844  hr = d3ddevice->SetTransform(D3DTS_WORLD, &identity_matrix);
-
2845  hr = d3ddevice->SetVertexShader(NULL);
-
2846  hr = d3ddevice->SetFVF(VideoDX9LineVertex::FVF);
-
2847  hr = d3ddevice->SetTexture(0, 0);
-
2848  hr = d3ddevice->DrawPrimitiveUP(
-
2849  D3DPT_POINTLIST,
-
2850  nverts,
-
2851  verts,
-
2852  sizeof(VideoDX9LineVertex));
-
2853 
-
2854  delete [] verts;
-
2855  return true;
-
2856  }
-
2857  }
-
2858 
-
2859  return false;
-
2860 }
-
2861 
-
2862 // +--------------------------------------------------------------------+
-
2863 
-
2864 bool
-
2865 VideoDX9::UseMaterial(Material* m)
-
2866 {
-
2867  use_material = m;
-
2868  return true;
-
2869 }
-
2870 
-
2871 // +--------------------------------------------------------------------+
-
2872 
-
2873 bool
-
2874 VideoDX9::UseXFont(const char* name, int size, bool bold, bool ital)
-
2875 {
-
2876  if (d3ddevice && name && *name && size > 4) {
-
2877  RELEASE(d3dx_font);
-
2878 
-
2879  strcpy_s(font_name, name);
-
2880  font_size = size;
-
2881  font_bold = bold;
-
2882  font_ital = ital;
-
2883 
-
2884  HRESULT hr = E_FAIL;
-
2885  HDC hdc = GetDC(NULL);
-
2886  int nLogPixelsY = GetDeviceCaps(hdc, LOGPIXELSY);
-
2887 
-
2888  ReleaseDC(NULL, hdc);
-
2889 
-
2890  int nHeight = -size * nLogPixelsY / 72;
-
2891 
-
2892  hr = D3DXCreateFont(d3ddevice, // D3D device
-
2893  nHeight, // Height
-
2894  0, // Width
-
2895  bold ? FW_BOLD : FW_NORMAL, // Weight
-
2896  1, // MipLevels, 0 = autogen mipmaps
-
2897  ital, // Italic
-
2898  DEFAULT_CHARSET, // CharSet
-
2899  OUT_DEFAULT_PRECIS, // OutputPrecision
-
2900  DEFAULT_QUALITY, // Quality
-
2901  DEFAULT_PITCH | FF_DONTCARE, // PitchAndFamily
-
2902  name, // pFaceName
-
2903  &d3dx_font); // ppFont
-
2904 
-
2905  if (SUCCEEDED(hr)) {
-
2906  return true;
-
2907  }
-
2908  }
-
2909 
-
2910  RELEASE(d3dx_font);
-
2911  return false;
-
2912 }
-
2913 
-
2914 bool
-
2915 VideoDX9::DrawText(const char* text, int count, const Rect& rect, DWORD format, Color c)
-
2916 {
-
2917  if (d3ddevice && text && *text && d3dx_font) {
-
2918  RECT r;
-
2919  r.left = rect.x;
-
2920  r.top = rect.y;
-
2921  r.right = rect.x + rect.w;
-
2922  r.bottom = rect.y + rect.h;
-
2923 
-
2924  d3dx_font->DrawText(0, text, count, &r, format, c.Value());
-
2925  }
-
2926 
-
2927  return false;
-
2928 }
-
2929 
-
2930 // +--------------------------------------------------------------------+
-
2931 
-
2932 bool
-
2933 VideoDX9::PrepareSurface(Surface* surf)
-
2934 {
-
2935  if (surf) {
-
2936  int nverts = surf->NumVerts();
-
2937  int nindices = surf->NumIndices();
-
2938  bool detail = surf->GetVertexSet()->tu1 != 0;
-
2939  bool luminous = false;
-
2940  DWORD dynamic = 0;
-
2941 
-
2942  if (surf->GetModel()) {
-
2943  luminous = surf->GetModel()->IsLuminous();
-
2944  dynamic = surf->GetModel()->IsDynamic() ? D3DUSAGE_DYNAMIC : 0;
-
2945  }
-
2946 
-
2947  surface_has_tangent_data = !luminous && (surf->GetVertexSet()->tangent && surf->GetVertexSet()->binormal);
-
2948 
-
2949  VideoDX9SurfaceData* surf_data = (VideoDX9SurfaceData*) surf->GetVideoPrivateData();
-
2950 
-
2951  if (!surf_data) {
-
2952  surf_data = new(__FILE__,__LINE__) VideoDX9SurfaceData(surf->GetModel());
-
2953 
-
2954  surface_has_tangent_data = false;
-
2955 
-
2956  if (surf->GetVertexSet()->tangent && surf->GetVertexSet()->binormal) {
-
2957  surface_has_tangent_data = true;
-
2958  surf_data->vertex_buffer = new(__FILE__,__LINE__) VideoDX9VertexBuffer(
-
2959  this,
-
2960  nverts,
-
2961  sizeof(VideoDX9NormalVertex),
-
2962  0, // not an FVF vertex buffer
-
2963  dynamic | D3DUSAGE_WRITEONLY);
-
2964  }
-
2965 
-
2966  else if (detail) {
-
2967  surf_data->vertex_buffer = new(__FILE__,__LINE__) VideoDX9VertexBuffer(
-
2968  this,
-
2969  nverts,
-
2970  sizeof(VideoDX9DetailVertex),
-
2971  VideoDX9DetailVertex::FVF,
-
2972  dynamic | D3DUSAGE_WRITEONLY);
-
2973  }
-
2974 
-
2975  else if (luminous) {
-
2976  surf_data->vertex_buffer = new(__FILE__,__LINE__) VideoDX9VertexBuffer(
-
2977  this,
-
2978  nverts,
-
2979  sizeof(VideoDX9LuminousVertex),
-
2980  VideoDX9LuminousVertex::FVF,
-
2981  dynamic | D3DUSAGE_WRITEONLY);
-
2982  }
-
2983 
-
2984  else {
-
2985  surf_data->vertex_buffer = new(__FILE__,__LINE__) VideoDX9VertexBuffer(
-
2986  this,
-
2987  nverts,
-
2988  sizeof(VideoDX9SolidVertex),
-
2989  VideoDX9SolidVertex::FVF,
-
2990  dynamic | D3DUSAGE_WRITEONLY);
-
2991  }
-
2992 
-
2993  surf_data->index_buffer = new(__FILE__,__LINE__) VideoDX9IndexBuffer(
-
2994  this,
-
2995  nindices,
-
2996  dynamic | D3DUSAGE_WRITEONLY);
-
2997 
-
2998  if (!surf_data->vertex_buffer || !surf_data->index_buffer) {
-
2999  Print("VideoDX9: Unable to prepare surface '%s'\n", surf->Name());
-
3000  delete surf_data;
-
3001  return false;
-
3002  }
-
3003 
-
3004  surf->SetVideoPrivateData(surf_data);
-
3005  }
-
3006 
-
3007  if (surf_data && !surf_data->IsValid()) {
-
3008  if (detail) {
-
3009  VideoDX9DetailVertex* v = (VideoDX9DetailVertex*) surf_data->vertex_buffer->Lock(nverts);
-
3010 
-
3011  if (v) {
-
3012  const VertexSet* vset = surf->GetVertexSet();
-
3013  for (int i = 0; i < nverts; i++) {
-
3014  v->x = vset->loc[i].x;
-
3015  v->y = vset->loc[i].y;
-
3016  v->z = vset->loc[i].z;
-
3017 
-
3018  v->diffuse = vset->diffuse[i];
-
3019  v->specular = vset->specular[i];
-
3020 
-
3021  v->tu = vset->tu[i];
-
3022  v->tv = vset->tv[i];
-
3023  v->tu1 = vset->tu1[i];
-
3024  v->tv1 = vset->tv1[i];
-
3025 
-
3026  v++;
-
3027  }
-
3028 
-
3029  surf_data->vertex_buffer->Unlock();
-
3030  }
-
3031  }
-
3032 
-
3033  else if (luminous) {
-
3034  VideoDX9LuminousVertex* v = (VideoDX9LuminousVertex*) surf_data->vertex_buffer->Lock(nverts);
-
3035 
-
3036  if (v) {
-
3037  const VertexSet* vset = surf->GetVertexSet();
-
3038  for (int i = 0; i < nverts; i++) {
-
3039  v->x = vset->loc[i].x;
-
3040  v->y = vset->loc[i].y;
-
3041  v->z = vset->loc[i].z;
-
3042 
-
3043  v->diffuse = vset->diffuse[i];
-
3044 
-
3045  v->tu = vset->tu[i];
-
3046  v->tv = vset->tv[i];
-
3047 
-
3048  v++;
-
3049  }
-
3050 
-
3051  surf_data->vertex_buffer->Unlock();
-
3052  }
-
3053  }
-
3054 
-
3055  else if (surface_has_tangent_data) {
-
3056  VideoDX9NormalVertex* v = (VideoDX9NormalVertex*) surf_data->vertex_buffer->Lock(nverts);
-
3057 
-
3058  if (v) {
-
3059  const VertexSet* vset = surf->GetVertexSet();
-
3060  for (int i = 0; i < nverts; i++) {
-
3061  v->x = vset->loc[i].x;
-
3062  v->y = vset->loc[i].y;
-
3063  v->z = vset->loc[i].z;
-
3064 
-
3065  v->nx = vset->nrm[i].x;
-
3066  v->ny = vset->nrm[i].y;
-
3067  v->nz = vset->nrm[i].z;
-
3068 
-
3069  v->t0u = vset->tu[i];
-
3070  v->t0v = vset->tv[i];
-
3071  v->t1u = vset->tu[i];
-
3072  v->t1v = vset->tv[i];
-
3073 
-
3074  v->tx = vset->tangent[i].x;
-
3075  v->ty = vset->tangent[i].y;
-
3076  v->tz = vset->tangent[i].z;
-
3077 
-
3078  v->bx = vset->binormal[i].x;
-
3079  v->by = vset->binormal[i].y;
-
3080  v->bz = vset->binormal[i].z;
-
3081 
-
3082  v++;
-
3083  }
-
3084 
-
3085  surf_data->vertex_buffer->Unlock();
-
3086  }
-
3087  }
-
3088 
-
3089  else {
-
3090  VideoDX9SolidVertex* v = (VideoDX9SolidVertex*) surf_data->vertex_buffer->Lock(nverts);
-
3091 
-
3092  if (v) {
-
3093  const VertexSet* vset = surf->GetVertexSet();
-
3094  for (int i = 0; i < nverts; i++) {
-
3095  v->x = vset->loc[i].x;
-
3096  v->y = vset->loc[i].y;
-
3097  v->z = vset->loc[i].z;
-
3098 
-
3099  v->nx = vset->nrm[i].x;
-
3100  v->ny = vset->nrm[i].y;
-
3101  v->nz = vset->nrm[i].z;
-
3102 
-
3103  v->tu = vset->tu[i];
-
3104  v->tv = vset->tv[i];
-
3105 
-
3106  v++;
-
3107  }
-
3108 
-
3109  surf_data->vertex_buffer->Unlock();
-
3110  }
-
3111  }
-
3112 
-
3113  WORD* indices = surf_data->index_buffer->Lock(nindices);
-
3114 
-
3115  if (indices) {
-
3116  // copy the indices into the locked index buffer
-
3117  WORD* s = indices;
-
3118  Poly* p = surf->GetPolys();
-
3119 
-
3120  for (int i = 0; i < surf->NumPolys(); i++) {
-
3121  if (p->nverts == 3) {
-
3122  *s++ = p->verts[0];
-
3123  *s++ = p->verts[2];
-
3124  *s++ = p->verts[1];
-
3125  }
-
3126  else if (p->nverts == 4) {
-
3127  *s++ = p->verts[0];
-
3128  *s++ = p->verts[2];
-
3129  *s++ = p->verts[1];
-
3130 
-
3131  *s++ = p->verts[0];
-
3132  *s++ = p->verts[3];
-
3133  *s++ = p->verts[2];
-
3134  }
-
3135 
-
3136  p++;
-
3137  }
-
3138 
-
3139  surf_data->index_buffer->Unlock();
-
3140  }
-
3141 
-
3142  surf_data->Validate();
-
3143  }
-
3144 
-
3145  int first_index = 0;
-
3146 
-
3147  ListIter<Segment> seg_iter = surf->GetSegments();
-
3148  while (++seg_iter) {
-
3149  Segment* segment = seg_iter.value();
-
3150 
-
3151  if (!segment->video_data) {
-
3152  VideoDX9SegmentData* seg_data = new(__FILE__,__LINE__) VideoDX9SegmentData;
-
3153 
-
3154  int num_tris = 0;
-
3155  for (int i = 0; i < segment->npolys; i++)
-
3156  num_tris += segment->polys[i].nverts-2;
-
3157 
-
3158  seg_data->first_vert = 0;
-
3159  seg_data->num_verts = surf->NumVerts();
-
3160  seg_data->first_index = first_index;
-
3161  seg_data->num_tris = num_tris;
-
3162 
-
3163  segment->video_data = seg_data;
-
3164 
-
3165  first_index += num_tris * 3;
-
3166  }
-
3167  }
-
3168  }
-
3169 
-
3170  return true;
-
3171 }
-
3172 
-
3173 // +--------------------------------------------------------------------+
-
3174 
-
3175 int
-
3176 VideoDX9::PrepareMaterial(Material* m)
-
3177 {
-
3178  segment_material = m;
-
3179  strategy = 0;
-
3180  passes = 0;
-
3181 
-
3182  if (m) {
-
3183  int max_stages = 1;
-
3184  int max_textures = 1;
-
3185  bool multiply_add = false;
-
3186  bool dotproduct3 = false;
-
3187  bool vertexshader = false;
-
3188  bool pixelshader = false;
-
3189  DWORD vs_version = 0;
-
3190  DWORD ps_version = 0;
-
3191 
-
3192  VideoDX9DeviceInfo* dev_info = dx9enum->GetDeviceInfo(video_settings.GetDeviceType());
-
3193 
-
3194  if (dev_info) {
-
3195  max_stages = (int) dev_info->caps.MaxTextureBlendStages;
-
3196  max_textures = (int) dev_info->caps.MaxSimultaneousTextures;
-
3197  multiply_add = (dev_info->caps.TextureOpCaps & D3DTEXOPCAPS_MULTIPLYADD) ? true : false;
-
3198  dotproduct3 = (dev_info->caps.TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3) ? true : false;
-
3199 
-
3200  vs_version = video_settings.enable_vs ? dev_info->caps.VertexShaderVersion : 0;
-
3201  ps_version = video_settings.enable_ps ? dev_info->caps.PixelShaderVersion : 0;
-
3202 
-
3203  vertexshader = vs_version >= D3DVS_VERSION(1,1);
-
3204  pixelshader = ps_version >= D3DPS_VERSION(2,0);
-
3205  }
-
3206 
-
3207  strategy = DX9_STRATEGY_SIMPLE;
-
3208  passes = 1;
-
3209 
-
3210  if (m->tex_alternate) {
-
3211  if (m->tex_detail && max_textures > 2 && max_stages > 4)
-
3212  strategy = DX9_STRATEGY_BLEND_DETAIL;
-
3213 
-
3214  else if (max_textures > 1 && max_stages > 3)
-
3215  strategy = DX9_STRATEGY_BLEND;
-
3216  }
-
3217 
-
3218  else if (m->tex_emissive && (!m->tex_diffuse || m->tex_diffuse == m->tex_emissive)) {
-
3219  strategy = DX9_STRATEGY_GLOW;
-
3220  }
-
3221 
-
3222  else if (IsSpecMapEnabled() && m->tex_specular && !m->tex_emissive) {
-
3223  strategy = DX9_STRATEGY_SPECMAP;
-
3224 
-
3225  if (max_textures < 2 || max_stages < 2 || !multiply_add)
-
3226  passes = 2;
-
3227  }
-
3228 
-
3229  else if ((!IsSpecMapEnabled() || !m->tex_specular) && m->tex_emissive) {
-
3230  strategy = DX9_STRATEGY_EMISSIVE;
-
3231 
-
3232  if (max_textures < 2 || max_stages < 2)
-
3233  passes = 2;
-
3234  }
-
3235 
-
3236  else if (IsSpecMapEnabled() && m->tex_specular && m->tex_emissive) {
-
3237  strategy = DX9_STRATEGY_SPEC_EMISSIVE;
-
3238 
-
3239  if (max_textures < 2 || max_stages < 2)
-
3240  passes = 3;
-
3241 
-
3242  else if (max_textures < 3 || max_stages < 3 || !multiply_add)
-
3243  passes = 2;
-
3244  }
-
3245  }
-
3246 
-
3247  return passes;
-
3248 }
-
3249 
-
3250 bool
-
3251 VideoDX9::SetupPass(int pass)
-
3252 {
-
3253  if (pass < 0 || pass >= passes)
-
3254  return false;
-
3255 
-
3256  if (pass == 0) {
-
3257  D3DMATERIAL9 d3dmtl;
-
3258  IDirect3DTexture9* texture_0 = 0;
-
3259  IDirect3DTexture9* texture_1 = 0;
-
3260  IDirect3DTexture9* texture_2 = 0;
-
3261  Bitmap* tex_bmp_0 = 0;
-
3262  Bitmap* tex_bmp_1 = 0;
-
3263  Bitmap* tex_bmp_2 = 0;
-
3264  ColorValue orig_spec = segment_material->Ks;
-
3265  HRESULT hr = E_FAIL;
-
3266 
-
3267  if (segment_material->tex_specular && passes > 1)
-
3268  segment_material->Ks = Color::Black;
-
3269 
-
3270  CreateD3DMaterial(d3dmtl, *segment_material);
-
3271  segment_material->Ks = orig_spec;
-
3272 
-
3273  hr = d3ddevice->SetMaterial(&d3dmtl);
-
3274 
-
3275  if (strategy == DX9_STRATEGY_SIMPLE) {
-
3276  tex_bmp_0 = segment_material->tex_diffuse;
-
3277  }
-
3278 
-
3279  else if (strategy == DX9_STRATEGY_BLEND) {
-
3280  tex_bmp_0 = segment_material->tex_diffuse;
-
3281  tex_bmp_1 = segment_material->tex_alternate;
-
3282  }
-
3283 
-
3284  else if (strategy == DX9_STRATEGY_BLEND_DETAIL) {
-
3285  tex_bmp_0 = segment_material->tex_diffuse;
-
3286  tex_bmp_1 = segment_material->tex_alternate;
-
3287  tex_bmp_2 = segment_material->tex_detail;
-
3288  }
-
3289 
-
3290  else if (strategy == DX9_STRATEGY_SPECMAP) {
-
3291  if (passes == 1) {
-
3292  tex_bmp_0 = segment_material->tex_diffuse;
-
3293  tex_bmp_1 = segment_material->tex_specular;
-
3294  }
-
3295  else {
-
3296  tex_bmp_0 = segment_material->tex_diffuse;
-
3297  }
-
3298  }
-
3299 
-
3300  else if (strategy == DX9_STRATEGY_EMISSIVE && passes == 1 ||
-
3301  strategy == DX9_STRATEGY_SPEC_EMISSIVE && passes == 2) {
-
3302  if (segment_material->tex_diffuse) {
-
3303  tex_bmp_0 = segment_material->tex_diffuse;
-
3304  tex_bmp_1 = segment_material->tex_emissive;
-
3305  }
-
3306  else {
-
3307  tex_bmp_0 = segment_material->tex_emissive;
-
3308  }
-
3309  }
-
3310 
-
3311  else {
-
3312  tex_bmp_0 = segment_material->tex_emissive;
-
3313  }
-
3314 
-
3315  if (texcache && tex_bmp_0) {
-
3316  texture_0 = texcache->FindTexture(tex_bmp_0);
-
3317 
-
3318  hr = d3ddevice->SetTexture(0, texture_0);
-
3319  current_texture = texture_0;
-
3320 
-
3321  if (tex_bmp_1) {
-
3322  texture_1 = texcache->FindTexture(tex_bmp_1);
-
3323  hr = d3ddevice->SetTexture(1, texture_1);
-
3324 
-
3325  if (tex_bmp_2) {
-
3326  texture_2 = texcache->FindTexture(tex_bmp_2);
-
3327  hr = d3ddevice->SetTexture(2, texture_2);
-
3328  }
-
3329  }
-
3330  }
-
3331  else {
-
3332  hr = d3ddevice->SetTexture(0, 0);
-
3333  current_texture = 0;
-
3334  }
-
3335 
-
3336  SetBlendType(segment_material->blend);
-
3337 
-
3338  if (texture_0 && texture_1 && strategy == DX9_STRATEGY_BLEND) {
-
3339  d3ddevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
3340  d3ddevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
3341  d3ddevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
-
3342 
-
3343  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
-
3344  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3345  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3346  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
-
3347 
-
3348  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_BLENDCURRENTALPHA);
-
3349  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
-
3350  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TEXTURE);
-
3351  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3352  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
-
3353  d3ddevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 0);
-
3354 
-
3355  d3ddevice->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_MODULATE);
-
3356  d3ddevice->SetTextureStageState(2, D3DTSS_COLORARG1, D3DTA_CURRENT);
-
3357  d3ddevice->SetTextureStageState(2, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
-
3358  d3ddevice->SetTextureStageState(2, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3359  d3ddevice->SetTextureStageState(2, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
-
3360 
-
3361  d3ddevice->SetTextureStageState(3, D3DTSS_COLOROP, D3DTOP_DISABLE);
-
3362  }
-
3363 
-
3364  else if (texture_0 && texture_1 && texture_2 && strategy == DX9_STRATEGY_BLEND_DETAIL) {
-
3365  d3ddevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
3366  d3ddevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
3367  d3ddevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
-
3368  d3ddevice->SetSamplerState(2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
3369  d3ddevice->SetSamplerState(2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
3370  d3ddevice->SetSamplerState(2, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
-
3371 
-
3372  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
-
3373  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3374  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3375  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
-
3376  d3ddevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
-
3377 
-
3378  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_BLENDCURRENTALPHA);
-
3379  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
-
3380  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TEXTURE);
-
3381  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3382  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
-
3383  d3ddevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 0);
-
3384 
-
3385  d3ddevice->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_BLENDTEXTUREALPHA);
-
3386  d3ddevice->SetTextureStageState(2, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3387  d3ddevice->SetTextureStageState(2, D3DTSS_COLORARG2, D3DTA_CURRENT);
-
3388  d3ddevice->SetTextureStageState(2, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3389  d3ddevice->SetTextureStageState(2, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
-
3390  d3ddevice->SetTextureStageState(2, D3DTSS_TEXCOORDINDEX, 1);
-
3391 
-
3392  d3ddevice->SetTextureStageState(3, D3DTSS_COLOROP, D3DTOP_MODULATE);
-
3393  d3ddevice->SetTextureStageState(3, D3DTSS_COLORARG1, D3DTA_CURRENT);
-
3394  d3ddevice->SetTextureStageState(3, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
-
3395  d3ddevice->SetTextureStageState(3, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3396  d3ddevice->SetTextureStageState(3, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
-
3397  }
-
3398 
-
3399  else if (texture_0 && strategy == DX9_STRATEGY_GLOW) {
-
3400  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
-
3401  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3402  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
-
3403  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3404  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
3405  }
-
3406 
-
3407  else if (texture_0) {
-
3408  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
-
3409  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3410  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
-
3411  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3412  d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
3413  }
-
3414 
-
3415  if (texture_1 && strategy == DX9_STRATEGY_SPECMAP) {
-
3416  d3ddevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
3417  d3ddevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
3418  d3ddevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
-
3419 
-
3420  d3ddevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 0);
-
3421  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MULTIPLYADD);
-
3422  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3423  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_SPECULAR);
-
3424  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3425  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
3426  }
-
3427 
-
3428  else if (texture_1 && strategy == DX9_STRATEGY_EMISSIVE) {
-
3429  d3ddevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
3430  d3ddevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
3431  d3ddevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
-
3432 
-
3433  d3ddevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 0);
-
3434  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_ADD);
-
3435  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3436  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
-
3437  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3438  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
3439  }
-
3440 
-
3441  else if (texture_1 && strategy == DX9_STRATEGY_SPEC_EMISSIVE) {
-
3442  d3ddevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
-
3443  d3ddevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-
3444  d3ddevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
-
3445 
-
3446  d3ddevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 0);
-
3447  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_ADD);
-
3448  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3449  d3ddevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
-
3450  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
-
3451  d3ddevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-
3452  }
-
3453 
-
3454  else if (strategy < DX9_STRATEGY_BLEND) {
-
3455  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
-
3456  }
-
3457  }
-
3458 
-
3459  else if (pass == 1) {
-
3460  D3DMATERIAL9 d3dmtl;
-
3461  IDirect3DTexture9* texture = 0;
-
3462  Bitmap* tex_bmp = 0;
-
3463  ColorValue orig_Ka = segment_material->Ka;
-
3464  ColorValue orig_Kd = segment_material->Kd;
-
3465  HRESULT hr = E_FAIL;
-
3466 
-
3467  if (segment_material->tex_specular) {
-
3468  segment_material->Ka = Color::Black;
-
3469  segment_material->Kd = Color::Black;
-
3470  }
-
3471 
-
3472  CreateD3DMaterial(d3dmtl, *segment_material);
-
3473 
-
3474  segment_material->Ka = orig_Ka;
-
3475  segment_material->Kd = orig_Kd;
-
3476 
-
3477  hr = d3ddevice->SetMaterial(&d3dmtl);
-
3478 
-
3479  if (strategy == DX9_STRATEGY_SPECMAP ||
-
3480  strategy == DX9_STRATEGY_SPEC_EMISSIVE) {
-
3481  tex_bmp = segment_material->tex_specular;
-
3482  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
-
3483  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3484  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_SPECULAR);
-
3485  }
-
3486 
-
3487  else if (strategy == DX9_STRATEGY_EMISSIVE) {
-
3488  tex_bmp = segment_material->tex_emissive;
-
3489  d3ddevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
-
3490  d3ddevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-
3491  }
-
3492 
-
3493  d3ddevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
-
3494 
-
3495  if (texcache && tex_bmp) {
-
3496  texture = texcache->FindTexture(tex_bmp);
-
3497  hr = d3ddevice->SetTexture(0, texture);
-
3498  current_texture = texture;
-
3499 
-
3500  SetBlendType(BLEND_ADDITIVE);
-
3501  }
-
3502  }
-
3503 
-
3504  if (render_state[STENCIL_ENABLE]) {
-
3505  d3ddevice->SetRenderState(D3DRS_STENCILENABLE, TRUE);
-
3506  d3ddevice->SetRenderState(D3DRS_STENCILREF, 0x01);
-
3507  d3ddevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_GREATER);
-
3508  }
-
3509  else {
-
3510  d3ddevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
-
3511  }
-
3512 
-
3513  if (render_state[LIGHTING_PASS] > 0) {
-
3514  SetBlendType(BLEND_ADDITIVE);
-
3515  SetRenderState(Z_WRITE_ENABLE, FALSE);
-
3516  }
-
3517 
-
3518  return true;
-
3519 }
-
3520 
-
3521 
-
3522 // +--------------------------------------------------------------------+
-
3523 
-
3524 void
-
3525 VideoDX9Error(const char* msg, HRESULT err)
-
3526 {
-
3527  Print(" VideoDX9: %s. [%s]\n", msg, D3DErrStr(err));
-
3528 }
-
3529 
-
3530 char* D3DErrStr(HRESULT hr)
-
3531 {
-
3532  static char errstrbuf[128];
-
3533 
-
3534  switch (hr) {
-
3535  default:
-
3536  sprintf_s(errstrbuf, "Unrecognized error value = %08x.", hr);
-
3537  return errstrbuf;
-
3538 
-
3539  case D3D_OK:
-
3540  return "No error.";
-
3541 
-
3542  case D3DERR_WRONGTEXTUREFORMAT:
-
3543  return "Wrong texture format.";
-
3544 
-
3545  case D3DERR_UNSUPPORTEDCOLOROPERATION:
-
3546  return "Unsupported color operation.";
-
3547 
-
3548  case D3DERR_UNSUPPORTEDCOLORARG:
-
3549  return "Unsupported color argument.";
-
3550 
-
3551  case D3DERR_UNSUPPORTEDALPHAOPERATION:
-
3552  return "Unsupported alpha operation.";
-
3553 
-
3554  case D3DERR_UNSUPPORTEDALPHAARG:
-
3555  return "Unsupported alpha argument.";
-
3556 
-
3557  case D3DERR_TOOMANYOPERATIONS:
-
3558  return "Too many operations.";
-
3559 
-
3560  case D3DERR_CONFLICTINGTEXTUREFILTER:
-
3561  return "Conflicting texture filter.";
-
3562 
-
3563  case D3DERR_UNSUPPORTEDFACTORVALUE:
-
3564  return "Unsupported factor value.";
-
3565 
-
3566  case D3DERR_CONFLICTINGRENDERSTATE:
-
3567  return "Conflicting render state.";
-
3568 
-
3569  case D3DERR_UNSUPPORTEDTEXTUREFILTER:
-
3570  return "Unsupported texture filter.";
-
3571 
-
3572  case D3DERR_CONFLICTINGTEXTUREPALETTE:
-
3573  return "Conflicting texture palette.";
-
3574 
-
3575  case D3DERR_DRIVERINTERNALERROR:
-
3576  return "Driver internal error.";
-
3577 
-
3578 
-
3579  case D3DERR_NOTFOUND:
-
3580  return "Resource was not found.";
-
3581 
-
3582  case D3DERR_MOREDATA:
-
3583  return "More data?";
-
3584 
-
3585  case D3DERR_DEVICELOST:
-
3586  return "Device lost.";
-
3587 
-
3588  case D3DERR_DEVICENOTRESET:
-
3589  return "Device is not reset.";
-
3590 
-
3591  case D3DERR_NOTAVAILABLE:
-
3592  return "Not available.";
-
3593 
-
3594  case D3DERR_OUTOFVIDEOMEMORY:
-
3595  return "Out of video memory.";
-
3596 
-
3597  case E_OUTOFMEMORY:
-
3598  return "Out of system memory.";
-
3599 
-
3600  case D3DERR_INVALIDDEVICE:
-
3601  return "Invalid device selection.";
-
3602 
-
3603  case D3DERR_INVALIDCALL:
-
3604  return "Invalid call or parameter.";
-
3605 
-
3606  case D3DERR_DRIVERINVALIDCALL:
-
3607  return "Driver invalid call.";
-
3608 
-
3609  case D3DERR_WASSTILLDRAWING:
-
3610  return "The device was still drawing.";
-
3611 
-
3612  case D3DOK_NOAUTOGEN:
-
3613  return "Autogeneration is not supported by this device.";
-
3614 
-
3615  }
-
3616 }
-
3617 
-
-
- - - - -- cgit v1.1