?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dsrc isn't necessary for this repo
[client-tools.git] / src / external / 3rd / application / UiBuilder / UIDirect3DPrimaryCanvas.cpp
blob934d15c2ecfd57962c88f02eadaed9dbfe48a449
1 #include "FirstUiBuilder.h"
2 #include "UIDirect3DPrimaryCanvas.h"
3
4 #include "UIDirect3DTextureCanvas.h"
5 #include "UIUtils.h"
6
7 #include <cmath>
8
9 extern LPDIRECTDRAW7 gDirectDraw;
10 extern LPDIRECT3D7 gDirect3D;
11 LPDIRECTDRAWSURFACE7 gPrimarySurface = 0;
12
13 namespace UIDirect3DPrimaryCanvasNamespace
14 {
15 void updateRenderState (LPDIRECT3DDEVICE7 device, const D3DRENDERSTATETYPE state, const DWORD newValue)
16 {
17 DWORD oldValue;
18 if (device->GetRenderState (state, &oldValue) == D3D_OK && oldValue != newValue)
19 device->SetRenderState (state, newValue);
20 }
21
22 void updateTextureStageState (LPDIRECT3DDEVICE7 device, const DWORD stage, const D3DTEXTURESTAGESTATETYPE type, const DWORD newValue)
23 {
24 DWORD oldValue;
25 if (device->GetTextureStageState (stage, type, &oldValue) == D3D_OK && oldValue != newValue)
26 device->SetTextureStageState (stage, type, newValue);
27 }
28 }
29
30 using namespace UIDirect3DPrimaryCanvasNamespace;
31
32 UIDirect3DPrimaryCanvas::UIDirect3DPrimaryCanvas( const UISize &size, HWND hwnd, bool fullscreen ) :
33 UICanvas( size ),
34 mQuads (),
35 mShaderQuads (),
36 mShowShaders (true)
37 {
38 mWindow = hwnd;
39 mIsFullscreen = fullscreen;
40
41 mPrimarySurface = 0;
42 mBackBufferSurface = 0;
43 mRenderDevice = 0;
44 mClipper = 0;
45 mCurrentTexture = 0;
46 mShowTriangles = false;
47
48 memset( &mPreferedTexturePixelFormat, 0, sizeof( mPreferedTexturePixelFormat ) );
49 }
50
51 UIDirect3DPrimaryCanvas::~UIDirect3DPrimaryCanvas()
52 {
53 DestroyAll();
54 }
55
56 bool UIDirect3DPrimaryCanvas::IsA( const UITypeID Type ) const
57 {
58 return (Type == TUIDirect3DPrimaryCanvas) || UICanvas::IsA( Type );
59 }
60
61 UIBaseObject *UIDirect3DPrimaryCanvas::Clone( void ) const
62 {
63 return 0;
64 }
65
66 void UIDirect3DPrimaryCanvas::Attach( UIBaseObject *o )
67 {
68 UICanvas::Attach( o );
69
70 if( o && o->IsA( TUIDirect3DTextureCanvas ) )
71 mAttachedTextures.insert( reinterpret_cast<UIDirect3DTextureCanvas *>(o) );
72 }
73
74 void UIDirect3DPrimaryCanvas::Detach( UIBaseObject *o )
75 {
76 if( o && o->IsA( TUIDirect3DTextureCanvas ) )
77 {
78 assert( mAttachedTextures.find( reinterpret_cast<UIDirect3DTextureCanvas *>(o) ) != mAttachedTextures.end() );
79 mAttachedTextures.erase( mAttachedTextures.find( reinterpret_cast<UIDirect3DTextureCanvas *>(o) ) );
80 }
81
82 UICanvas::Detach( o );
83 }
84
85 void UIDirect3DPrimaryCanvas::DestroyAll( void )
86 {
87 if( mClipper )
88 {
89 mClipper->Release();
90 mClipper = 0;
91 }
92
93 if( mPrimarySurface )
94 {
95 mPrimarySurface->Release();
96 mPrimarySurface = 0;
97 }
98
99 if( mBackBufferSurface )
100 {
101 mBackBufferSurface->Release();
102 mBackBufferSurface = 0;
103 }
104
105 if( mRenderDevice )
106 {
107 mRenderDevice->Release();
108 mRenderDevice = 0;
109 }
110 }
111
112 void UIDirect3DPrimaryCanvas::SetSize( const UISize &NewSize )
113 {
114 UICanvas::SetSize( NewSize );
115 DestroyAll();
116 }
117
118 //----------------------------------------------------------------------
119
120 void UIDirect3DPrimaryCanvas::ShowTriangles( bool ShowTriangles )
121 {
122 mShowTriangles = ShowTriangles;
123 }
124
125 //----------------------------------------------------------------------
126
127 void UIDirect3DPrimaryCanvas::ShowShaders (bool b)
128 {
129 mShowShaders = b;
130 }
131
132 //----------------------------------------------------------------------
133
134 long UIDirect3DPrimaryCanvas::GetTriangleCount( void ) const
135 {
136 return mTriangleCount;
137 }
138
139 bool UIDirect3DPrimaryCanvas::Prepare( void ) const
140 {
141 return const_cast<UIDirect3DPrimaryCanvas *>( this )->Generate();
142 }
143
144 bool UIDirect3DPrimaryCanvas::Generate( void )
145 {
146 if( mPrimarySurface )
147 {
148 if( mPrimarySurface && mPrimarySurface->IsLost() )
149 {
150 HRESULT hr = mPrimarySurface->Restore();
151
152 if( FAILED( hr ) )
153 return false;
154 }
155
156 if( mBackBufferSurface && mBackBufferSurface->IsLost() )
157 {
158 HRESULT hr = mBackBufferSurface->Restore();
159
160 if( FAILED( hr ) )
161 return false;
162 }
163 return true;
164 }
165
166 try
167 {
168 DDSURFACEDESC2 ddsd = { sizeof( ddsd ) };
169 HRESULT hr;
170
171 if( mIsFullscreen )
172 {
173 ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
174 ddsd.ddsCaps.dwCaps = DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX | DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE;
175 ddsd.dwBackBufferCount = 1;
176
177 hr = gDirectDraw->CreateSurface( &ddsd, &mPrimarySurface, 0 );
178
179 if( FAILED( hr ) )
180 throw hr;
181 }
182 else
183 {
184 // Primary surface
185 ddsd.dwFlags = DDSD_CAPS;
186 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
187
188 hr = gDirectDraw->CreateSurface( &ddsd, &mPrimarySurface, 0 );
189
190 if( FAILED( hr ) )
191 {
192 if( hr == DDERR_PRIMARYSURFACEALREADYEXISTS )
193 {
194 mPrimarySurface = gPrimarySurface;
195 mPrimarySurface->AddRef();
196 }
197 else
198 throw hr;
199 }
200 else
201 {
202 gPrimarySurface = mPrimarySurface;
203 }
204
205 hr = gDirectDraw->CreateClipper( 0, &mClipper, 0 );
206
207 if( FAILED( hr ) )
208 throw hr;
209
210 hr = mClipper->SetHWnd( 0, mWindow );
211
212 if( FAILED( hr ) )
213 throw hr;
214
215 // Back buffer
216 ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
217 ddsd.dwWidth = GetWidth();
218 ddsd.dwHeight = GetHeight();
219 ddsd.ddsCaps.dwCaps = DDSCAPS_3DDEVICE | DDSCAPS_OFFSCREENPLAIN;
220 ddsd.ddsCaps.dwCaps2 = 0;
221
222 hr = gDirectDraw->CreateSurface( &ddsd, &mBackBufferSurface, 0 );
223
224 if( FAILED( hr ) )
225 throw hr;
226 }
227
228 static const GUID *DevicePreference[] =
229 {
230 &IID_IDirect3DTnLHalDevice,
231 &IID_IDirect3DHALDevice,
232 &IID_IDirect3DRGBDevice,
233 };
234
235 for( int i = 0; i < (sizeof( DevicePreference ) / sizeof( *DevicePreference )); ++i )
236 {
237 DDPIXELFORMAT OldPreferedTexturePixelFormat;
238
239 hr = gDirect3D->CreateDevice( *DevicePreference[i], mIsFullscreen ? mPrimarySurface : mBackBufferSurface, &mRenderDevice );
240
241 if( FAILED(hr) )
242 continue;
243
244 D3DVIEWPORT7 vp;
245
246 vp.dwX = 0;
247 vp.dwY = 0;
248 vp.dwWidth = GetWidth();
249 vp.dwHeight = GetHeight();
250 vp.dvMinZ = 0.0f;
251 vp.dvMaxZ = 1.0f;
252
253 hr = mRenderDevice->SetViewport( &vp );
254
255 if( FAILED(hr) )
256 throw hr;
257
258 updateRenderState( mRenderDevice, D3DRENDERSTATE_LIGHTING, FALSE );
259 updateRenderState( mRenderDevice, D3DRENDERSTATE_CLIPPING, FALSE );
260 updateRenderState( mRenderDevice, D3DRENDERSTATE_CULLMODE, D3DCULL_NONE );
261 updateRenderState( mRenderDevice, D3DRENDERSTATE_COLORVERTEX, FALSE );
262 updateRenderState( mRenderDevice, D3DRENDERSTATE_ZFUNC, D3DCMP_ALWAYS );
263 updateRenderState( mRenderDevice, D3DRENDERSTATE_LOCALVIEWER, FALSE );
264 updateRenderState( mRenderDevice, D3DRENDERSTATE_ALPHABLENDENABLE, TRUE );
265 updateRenderState( mRenderDevice, D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA );
266 updateRenderState( mRenderDevice, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA );
267
268 updateTextureStageState( mRenderDevice, 0, D3DTSS_MAGFILTER, D3DTFG_POINT );
269 updateTextureStageState( mRenderDevice, 0, D3DTSS_MINFILTER, D3DTFG_POINT );
270
271 updateTextureStageState( mRenderDevice, 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
272 updateTextureStageState( mRenderDevice, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
273 updateTextureStageState( mRenderDevice, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
274 updateTextureStageState( mRenderDevice, 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
275 updateTextureStageState( mRenderDevice, 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
276 updateTextureStageState( mRenderDevice, 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
277
278 updateTextureStageState( mRenderDevice, 0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP );
279 updateTextureStageState( mRenderDevice, 0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP );
280
281 OldPreferedTexturePixelFormat = mPreferedTexturePixelFormat;
282 ZeroMemory( &mPreferedTexturePixelFormat, sizeof(mPreferedTexturePixelFormat) );
283 hr = mRenderDevice->EnumTextureFormats( D3DEnumPixelFormatsStaticCallback, this );
284
285 if( FAILED(hr) )
286 throw hr;
287
288 if( memcmp( &OldPreferedTexturePixelFormat, &mPreferedTexturePixelFormat, sizeof( mPreferedTexturePixelFormat ) ) )
289 {
290 UIDirect3DTextureCanvasSet::iterator i;
291
292 for( i = mAttachedTextures.begin(); i != mAttachedTextures.end(); ++i )
293 (*i)->NotifyRenderCanvasChanged();
294 }
295
296 return true;
297 }
298
299 throw hr;
300 }
301 catch( HRESULT hr )
302 {
303 hr = hr;
304
305 if( mClipper )
306 {
307 mClipper->Release();
308 mClipper = 0;
309 }
310
311 if( mPrimarySurface )
312 {
313 mPrimarySurface->Release();
314 mPrimarySurface = 0;
315 }
316
317 if( mBackBufferSurface )
318 {
319 mBackBufferSurface->Release();
320 mBackBufferSurface = 0;
321 }
322
323 if( mRenderDevice )
324 {
325 mRenderDevice->Release();
326 mRenderDevice = 0;
327 }
328 }
329
330 return false;
331
332 }
333 void UIDirect3DPrimaryCanvas::ClearTo( const UIColor &c, const UIRect & rc)
334 {
335 //-----------------------------------------------------------------
336 //-- don't count triangles for clearing
337
338 mTriangleCount -= 2;
339
340 UICanvas::ClearTo (c, rc);
341 }
342
343 void UIDirect3DPrimaryCanvas::EnableFiltering( bool NewValue )
344 {
345 if( NewValue )
346 {
347 updateTextureStageState( mRenderDevice, 0, D3DTSS_MAGFILTER, D3DTFG_LINEAR );
348 updateTextureStageState( mRenderDevice, 0, D3DTSS_MINFILTER, D3DTFG_LINEAR );
349 }
350 else
351 {
352 updateTextureStageState( mRenderDevice, 0, D3DTSS_MAGFILTER, D3DTFG_POINT );
353 updateTextureStageState( mRenderDevice, 0, D3DTSS_MINFILTER, D3DTFG_POINT );
354 }
355 }
356
357 //----------------------------------------------------------------------
358 //
359 // Verts are passed in in this order:
360 // 0-----1
361 // | /|
362 // | / |
363 // | / |
364 // | / |
365 // |/ |
366 // 2-----3
367
368 void UIDirect3DPrimaryCanvas::RenderQuad( const UICanvas * const src, const UIFloatPoint VerticesIn[4], const UIFloatPoint UVs[4] )
369 {
370 static D3DTLVERTEX D3DVertices[4] =
371 {
372 { 0, 0, 0, 1, 0, 0, 0, 0 },
373 { 0, 0, 0, 1, 0, 0, 0, 0 },
374 { 0, 0, 0, 1, 0, 0, 0, 0 },
375 { 0, 0, 0, 1, 0, 0, 0, 0 },
376 };
377
378 const UIDirect3DTextureCanvas * SourceCanvas = 0;
379
380 if( src )
381 {
382 assert( src->IsA( TUIDirect3DTextureCanvas ) );
383
384 SourceCanvas = static_cast<const UIDirect3DTextureCanvas *>(src);
385
386 // if( mCurrentTexture != SourceCanvas->GetSurface() )
387 {
388 mCurrentTexture = SourceCanvas->GetSurface();
389 mRenderDevice->SetTexture( 0, mCurrentTexture );
390 }
391 }
392 else
393 mRenderDevice->SetTexture( 0, 0 );
394
395 DWORD dwVertexColor = mState.Color.FormatRGBA();
396
397 UIFloatPoint const * Vertices = VerticesIn;
398 if (IsDeforming())
399 {
400 UIFloatPoint NewVertices[4];
401 Deform(Vertices, NewVertices, 4);
402 Vertices = NewVertices;
403 }
404
405 // Copy data to vertex buffer, offseting geometry
406 // so texture centers lie on pixel centers
407 D3DVertices[0].sx = Vertices[0].x - 0.5f;
408 D3DVertices[0].sy = Vertices[0].y - 0.5f;
409 D3DVertices[0].tu = UVs[0].x;
410 D3DVertices[0].tv = UVs[0].y;
411 D3DVertices[0].color = dwVertexColor;
412 D3DVertices[1].sx = Vertices[1].x - 0.5f;
413 D3DVertices[1].sy = Vertices[1].y - 0.5f;
414 D3DVertices[1].tu = UVs[1].x;
415 D3DVertices[1].tv = UVs[1].y;
416 D3DVertices[1].color = dwVertexColor;
417 D3DVertices[2].sx = Vertices[2].x - 0.5f;
418 D3DVertices[2].sy = Vertices[2].y - 0.5f;
419 D3DVertices[2].tu = UVs[2].x;
420 D3DVertices[2].tv = UVs[2].y;
421 D3DVertices[2].color = dwVertexColor;
422 D3DVertices[3].sx = Vertices[3].x - 0.5f;
423 D3DVertices[3].sy = Vertices[3].y - 0.5f;
424 D3DVertices[3].tu = UVs[3].x;
425 D3DVertices[3].tv = UVs[3].y;
426 D3DVertices[3].color = dwVertexColor;
427
428 mTriangleCount += 2;
429
430 UI_IGNORE_RETURN (mRenderDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX, &D3DVertices, 4, 0 ));
431
432 if (mShowTriangles)
433 {
434 mQuads.push_back(
435 UIQuad(
436 static_cast<long>(Vertices [0].x), static_cast<long>(Vertices[0].y),
437 static_cast<long>(Vertices [1].x), static_cast<long>(Vertices[1].y),
438 static_cast<long>(Vertices [2].x), static_cast<long>(Vertices[2].y),
439 static_cast<long>(Vertices [3].x), static_cast<long>(Vertices[3].y)));
440 }
441
442 if (mShowShaders && SourceCanvas && SourceCanvas->GetHasShader ())
443 {
444 mShaderQuads.push_back(
445 UIQuad(
446 static_cast<long>(Vertices [0].x), static_cast<long>(Vertices[0].y),
447 static_cast<long>(Vertices [1].x), static_cast<long>(Vertices[1].y),
448 static_cast<long>(Vertices [2].x), static_cast<long>(Vertices[2].y),
449 static_cast<long>(Vertices [3].x), static_cast<long>(Vertices[3].y)));
450 }
451 }
452
453
454 //----------------------------------------------------------------------
455 //
456 // Verts are passed in in this order:
457 // 0-----1
458 // | /|
459 // | / |
460 // | / |
461 // | / |
462 // |/ |
463 // 2-----3
464
465 void UIDirect3DPrimaryCanvas::RenderQuad( const UICanvas * const src, const UIFloatPoint VerticesIn[4], const UIFloatPoint UVs[4], const UIColor Colors[4] )
466 {
467 static D3DTLVERTEX D3DVertices[4] =
468 {
469 { 0, 0, 0, 1, 0, 0, 0, 0 },
470 { 0, 0, 0, 1, 0, 0, 0, 0 },
471 { 0, 0, 0, 1, 0, 0, 0, 0 },
472 { 0, 0, 0, 1, 0, 0, 0, 0 },
473 };
474
475 const UIDirect3DTextureCanvas * SourceCanvas = 0;
476
477 if( src )
478 {
479 assert( src->IsA( TUIDirect3DTextureCanvas ) );
480
481 SourceCanvas = static_cast<const UIDirect3DTextureCanvas *>(src);
482
483 // if( mCurrentTexture != SourceCanvas->GetSurface() )
484 {
485 mCurrentTexture = SourceCanvas->GetSurface();
486 mRenderDevice->SetTexture( 0, mCurrentTexture );
487 }
488 }
489 else
490 mRenderDevice->SetTexture( 0, 0 );
491
492 UIFloatPoint const * Vertices = VerticesIn;
493 if (IsDeforming())
494 {
495 UIFloatPoint NewVertices[4];
496 Deform(Vertices, NewVertices, 4);
497 Vertices = NewVertices;
498 }
499
500 // Copy data to vertex buffer, offseting geometry
501 // so texture centers lie on pixel centers
502 D3DVertices[0].sx = Vertices[0].x - 0.5f;
503 D3DVertices[0].sy = Vertices[0].y - 0.5f;
504 D3DVertices[0].tu = UVs[0].x;
505 D3DVertices[0].tv = UVs[0].y;
506 D3DVertices[0].color = Colors[0].FormatRGBA();
507 D3DVertices[1].sx = Vertices[1].x - 0.5f;
508 D3DVertices[1].sy = Vertices[1].y - 0.5f;
509 D3DVertices[1].tu = UVs[1].x;
510 D3DVertices[1].tv = UVs[1].y;
511 D3DVertices[1].color = Colors[1].FormatRGBA();
512 D3DVertices[2].sx = Vertices[2].x - 0.5f;
513 D3DVertices[2].sy = Vertices[2].y - 0.5f;
514 D3DVertices[2].tu = UVs[2].x;
515 D3DVertices[2].tv = UVs[2].y;
516 D3DVertices[2].color = Colors[2].FormatRGBA();
517 D3DVertices[3].sx = Vertices[3].x - 0.5f;
518 D3DVertices[3].sy = Vertices[3].y - 0.5f;
519 D3DVertices[3].tu = UVs[3].x;
520 D3DVertices[3].tv = UVs[3].y;
521 D3DVertices[3].color = Colors[3].FormatRGBA();
522
523 mTriangleCount += 2;
524
525 UI_IGNORE_RETURN (mRenderDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX, &D3DVertices, 4, 0 ));
526
527 if (mShowTriangles)
528 {
529 mQuads.push_back(
530 UIQuad(
531 static_cast<long>(Vertices [0].x), static_cast<long>(Vertices[0].y),
532 static_cast<long>(Vertices [1].x), static_cast<long>(Vertices[1].y),
533 static_cast<long>(Vertices [2].x), static_cast<long>(Vertices[2].y),
534 static_cast<long>(Vertices [3].x), static_cast<long>(Vertices[3].y)));
535 }
536
537 if (mShowShaders && SourceCanvas && SourceCanvas->GetHasShader ())
538 {
539 mShaderQuads.push_back(
540 UIQuad(
541 static_cast<long>(Vertices [0].x), static_cast<long>(Vertices[0].y),
542 static_cast<long>(Vertices [1].x), static_cast<long>(Vertices[1].y),
543 static_cast<long>(Vertices [2].x), static_cast<long>(Vertices[2].y),
544 static_cast<long>(Vertices [3].x), static_cast<long>(Vertices[3].y)));
545 }
546 }
547
548 //----------------------------------------------------------------------
549
550 void UIDirect3DPrimaryCanvas::BltFrom( const UICanvas * const src, const UIPoint &Source, const UIPoint &Destination, const UISize &Size )
551 {
552 if( src )
553 static_cast<const UIDirect3DTextureCanvas *>( src )->Prepare();
554
555 Prepare();
556
557 UICanvas::BltFrom( src, Source, Destination, Size );
558 }
559
560 //----------------------------------------------------------------------
561
562 void UIDirect3DPrimaryCanvas::BltFromNoScaleOrRotate( const UICanvas * const srcarg, const UIPoint &Source, const UIPoint &Destination, const UISize &Size )
563 {
564 BltFrom( srcarg, Source, Destination, Size );
565 }
566
567
568 //----------------------------------------------------------------------
569
570 void UIDirect3DPrimaryCanvas::RenderLines (const UICanvas * const , int numLines, const UILine * lines, const UILine * )
571 {
572 const DWORD dwVertexColor = mState.Color.FormatRGBA();
573
574 mRenderDevice->SetTexture( 0, 0 );
575 mCurrentTexture = 0;
576
577 for (int i = 0; i < numLines; ++i)
578 {
579 const UILine & theLine = lines [i];
580
581 static D3DTLVERTEX Vertices[2] =
582 {
583 { 0, 0, 0, 1, 0, 0, 0, 0 },
584 { 0, 0, 0, 1, 0, 0, 0, 0 },
585 };
586
587 UIFloatPoint p;
588
589 p = Transform( theLine.p1 );
590 Vertices[0].sx = p.x;
591 Vertices[0].sy = p.y;
592 Vertices[0].color = dwVertexColor;
593
594 p = Transform( theLine.p2 );
595 Vertices[1].sx = p.x;
596 Vertices[1].sy = p.y;
597 Vertices[1].color = dwVertexColor;
598
599 mTriangleCount += 1;
600
601 UI_IGNORE_RETURN (mRenderDevice->DrawPrimitive( D3DPT_LINELIST, D3DFVF_TLVERTEX, &Vertices, 2, 0 ));
602 }
603 }
604
605 //----------------------------------------------------------------------
606
607 void UIDirect3DPrimaryCanvas::RenderLines(const UICanvas * const , int numLines, const UILine * lines, const UIFloatPoint * uvs, const UIColor * colors)
608 {
609 mRenderDevice->SetTexture( 0, 0 );
610 mCurrentTexture = 0;
611
612 static D3DTLVERTEX Vertices[2];
613 static UIFloatPoint p;
614
615 for (int i = 0; i < numLines; ++i)
616 {
617 const UILine & theLine = lines [i];
618 int index = i * 2;
619
620 Vertices[0].sx = theLine.p1.x;
621 Vertices[0].sy = theLine.p1.y;
622 Vertices[0].dvTU = (uvs + index)->x;
623 Vertices[0].dvTV = (uvs + index)->y;
624 Vertices[0].color = (colors + index)->FormatRGBA();
625
626 Vertices[1].sx = theLine.p2.x;
627 Vertices[1].sy = theLine.p2.y;
628 Vertices[1].dvTU = (uvs + index + 1)->x;
629 Vertices[1].dvTV = (uvs + index + 1)->y;
630 Vertices[1].color = (colors + index + 1)->FormatRGBA();
631
632 mTriangleCount += 1;
633
634 UI_IGNORE_RETURN (mRenderDevice->DrawPrimitive( D3DPT_LINELIST, D3DFVF_TLVERTEX, &Vertices, 2, 0 ));
635 }
636 }
637
638 //----------------------------------------------------------------------
639
640 void UIDirect3DPrimaryCanvas::RenderTriangles (const UICanvas * const src, int numTris, const UITriangle * tris, const UITriangle * uvs)
641 {
642 const DWORD dwVertexColor = mState.Color.FormatRGBA();
643
644 if( src )
645 {
646 assert( src->IsA( TUIDirect3DTextureCanvas ) );
647
648 const UIDirect3DTextureCanvas * const SourceCanvas = static_cast<const UIDirect3DTextureCanvas *>(src);
649 mCurrentTexture = SourceCanvas->GetSurface();
650 mRenderDevice->SetTexture( 0, mCurrentTexture );
651 }
652 else
653 mRenderDevice->SetTexture( 0, 0 );
654
655 for (int i = 0; i < numTris; ++i)
656 {
657 const UITriangle & theTri = tris [i];
658 const UITriangle & theUvs = uvs [i];
659
660 static D3DTLVERTEX Vertices[3] =
661 {
662 { 0, 0, 0, 1, 0, 0, 0, 0 },
663 { 0, 0, 0, 1, 0, 0, 0, 0 },
664 { 0, 0, 0, 1, 0, 0, 0, 0 }
665 };
666
667 UIFloatPoint p;
668 UIFloatPoint uv;
669
670 p = theTri.p1;
671 uv = theUvs.p1;
672 Vertices[0].sx = p.x;
673 Vertices[0].sy = p.y;
674 Vertices[0].tu = uv.x;
675 Vertices[0].tv = uv.y;
676 Vertices[0].color = dwVertexColor;
677
678 p = theTri.p2;
679 uv = theUvs.p2;
680 Vertices[1].sx = p.x;
681 Vertices[1].sy = p.y;
682 Vertices[1].tu = uv.x;
683 Vertices[1].tv = uv.y;
684 Vertices[1].color = dwVertexColor;
685
686 p = theTri.p3;
687 uv = theUvs.p3;
688 Vertices[2].sx = p.x;
689 Vertices[2].sy = p.y;
690 Vertices[2].tu = uv.x;
691 Vertices[2].tv = uv.y;
692 Vertices[2].color = dwVertexColor;
693
694 ++mTriangleCount;
695
696 if (mShowTriangles)
697 {
698 mQuads.push_back(
699 UIQuad(
700 static_cast<long>(Vertices [0].sx), static_cast<long>(Vertices[0].sy),
701 static_cast<long>(Vertices [1].sx), static_cast<long>(Vertices[1].sy),
702 static_cast<long>(Vertices [2].sx), static_cast<long>(Vertices[2].sy),
703 static_cast<long>(Vertices [0].sx), static_cast<long>(Vertices[0].sy)));
704 }
705
706 UI_IGNORE_RETURN (mRenderDevice->DrawPrimitive( D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, &Vertices, 3, 0 ));
707 }
708 }
709
710 //----------------------------------------------------------------------
711
712 bool UIDirect3DPrimaryCanvas::BeginRendering( void )
713 {
714 UICanvas::BeginRendering();
715
716 HRESULT hr;
717
718 mCurrentTexture = 0;
719
720 if( !Prepare() || !mRenderDevice )
721 return false;
722
723 hr = mPrimarySurface->SetClipper( mClipper );
724
725 if( FAILED( hr ) )
726 return false;
727
728 hr = mRenderDevice->BeginScene();
729
730 if( FAILED(hr) )
731 return false;
732
733 mTriangleCount = 0;
734
735 return true;
736 }
737
738 //----------------------------------------------------------------------
739
740 void UIDirect3DPrimaryCanvas::EndRendering( void )
741 {
742 UICanvas::EndRendering();
743
744 assert( mRenderDevice );
745
746 mRenderDevice->SetTexture( 0, 0 );
747 DWORD dwOldState;
748 mRenderDevice->GetRenderState( D3DRENDERSTATE_FILLMODE, &dwOldState );
749
750 if( mShowTriangles && !mQuads.empty ())
751 {
752 D3DTLVERTEX Vertices[4];
753
754 updateRenderState( mRenderDevice, D3DRENDERSTATE_FILLMODE, D3DFILL_WIREFRAME );
755
756 for( int i = 0; i < 4; ++i )
757 {
758 Vertices[i].sz = 0.0;
759 Vertices[i].rhw = 1.0;
760 Vertices[i].color = 0xFFFFFFFF;
761 }
762
763 for( UIQuadList::iterator CurrentQuad = mQuads.begin(); CurrentQuad != mQuads.end(); ++CurrentQuad )
764 {
765 const UIQuad & q = *CurrentQuad;
766
767 // Top Left
768 Vertices[0].sx = static_cast<float>(q.p1.x);
769 Vertices[0].sy = static_cast<float>(q.p1.y);
770
771 // Top Right
772 Vertices[1].sx = static_cast<float>(q.p2.x);
773 Vertices[1].sy = static_cast<float>(q.p2.y);
774
775 // Bottom Left
776 Vertices[2].sx = static_cast<float>(q.p3.x);
777 Vertices[2].sy = static_cast<float>(q.p3.y);
778
779 // Bottom Right
780 Vertices[3].sx = static_cast<float>(q.p4.x);
781 Vertices[3].sy = static_cast<float>(q.p4.y);
782
783 mRenderDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX, &Vertices, 4, 0 );
784 }
785 mQuads.clear();
786 }
787
788 //----------------------------------------------------------------------
789
790 if(!mShaderQuads.empty ())
791 {
792 D3DTLVERTEX Vertices[5];
793
794 updateRenderState( mRenderDevice, D3DRENDERSTATE_FILLMODE, D3DFILL_WIREFRAME );
795
796 for( int i = 0; i < 4; ++i )
797 {
798 Vertices[i].sz = 0.0;
799 Vertices[i].rhw = 1.0;
800 Vertices[i].color = 0xaaFFaa00;
801 }
802
803 for( UIQuadList::iterator CurrentQuad = mShaderQuads.begin(); CurrentQuad != mShaderQuads.end(); ++CurrentQuad )
804 {
805 const UIQuad & q = *CurrentQuad;
806
807 // Top Left
808 Vertices[0].sx = static_cast<float>(q.p1.x);
809 Vertices[0].sy = static_cast<float>(q.p1.y);
810
811 // Top Right
812 Vertices[1].sx = static_cast<float>(q.p2.x);
813 Vertices[1].sy = static_cast<float>(q.p2.y);
814
815 // Bottom Right
816 Vertices[2].sx = static_cast<float>(q.p4.x);
817 Vertices[2].sy = static_cast<float>(q.p4.y);
818
819 // Bottom Left
820 Vertices[3].sx = static_cast<float>(q.p3.x);
821 Vertices[3].sy = static_cast<float>(q.p3.y);
822
823 // Top Left
824 Vertices[4] = Vertices [0];
825
826 mRenderDevice->DrawPrimitive( D3DPT_LINESTRIP, D3DFVF_TLVERTEX, &Vertices, 5, 0 );
827 }
828 mShaderQuads.clear();
829 }
830
831 updateRenderState( mRenderDevice, D3DRENDERSTATE_FILLMODE, dwOldState );
832
833 mRenderDevice->EndScene();
834 }
835
836 //----------------------------------------------------------------------
837
838 void UIDirect3DPrimaryCanvas::Flip( void )
839 {
840 HRESULT hr;
841
842 assert( mPrimarySurface );
843 assert( mIsFullscreen || mBackBufferSurface );
844
845 if( mIsFullscreen )
846 hr = mPrimarySurface->Flip( 0, DDFLIP_WAIT );
847 else
848 {
849 POINT theOrigin;
850 RECT rcDest;
851 RECT rcSrc;
852
853 theOrigin.x = 0;
854 theOrigin.y = 0;
855
856 ClientToScreen( mWindow, &theOrigin );
857
858 rcDest.left = theOrigin.x;
859 rcDest.top = theOrigin.y;
860 rcDest.right = theOrigin.x + GetWidth();
861 rcDest.bottom = theOrigin.y + GetHeight();
862
863 rcSrc.left = 0;
864 rcSrc.top = 0;
865 rcSrc.right = GetWidth();
866 rcSrc.bottom = GetHeight();
867
868 hr = mPrimarySurface->Blt( &rcDest, mBackBufferSurface, &rcSrc, DDBLT_WAIT, 0 );
869 }
870 }
871
872 void UIDirect3DPrimaryCanvas::GetPreferedPixelFormat( LPDDPIXELFORMAT lpddpf )
873 {
874 *lpddpf = mPreferedTexturePixelFormat;
875 }
876
877 HRESULT UIDirect3DPrimaryCanvas::D3DEnumPixelFormats( LPDDPIXELFORMAT lppf )
878 {
879 // We need surfaces with both RGB and alpha components
880 if( !(lppf->dwFlags & DDPF_RGB) || !(lppf->dwFlags & DDPF_ALPHAPIXELS) )
881 return D3DENUMRET_OK;
882
883 // Alpha must be at least 8 bits
884 if( lppf->dwAlphaBitDepth < 8 )
885 return D3DENUMRET_OK;
886
887 // RGB must be at least 16 bits
888 if( lppf->dwRGBBitCount < 16 )
889 return D3DENUMRET_OK;
890
891 // If this is the first pixel format that meets these criteria use it for now
892 if( mPreferedTexturePixelFormat.dwSize == 0 )
893 {
894 mPreferedTexturePixelFormat = *lppf;
895 return D3DENUMRET_OK;
896 }
897
898 if( lppf->dwRGBBitCount >= mPreferedTexturePixelFormat.dwRGBBitCount )
899 mPreferedTexturePixelFormat = *lppf;
900
901 return D3DENUMRET_OK;
902 }
903
904 HRESULT CALLBACK UIDirect3DPrimaryCanvas::D3DEnumPixelFormatsStaticCallback( LPDDPIXELFORMAT lppf, LPVOID arg )
905 {
906 return reinterpret_cast<UIDirect3DPrimaryCanvas *>(arg)->D3DEnumPixelFormats( lppf );
907 }
908
909 HWND UIDirect3DPrimaryCanvas::GetWindow( void )
910 {
911 return mWindow;
912 }
913
914 bool UIDirect3DPrimaryCanvas::MatchPixelFormat( LPDDPIXELFORMAT FormatToMatch, LPDDPIXELFORMAT BestMatch )
915 {
916 HRESULT hr;
917
918 mBestMatchFound = false;
919 mFormatToMatch = *FormatToMatch;
920
921 hr = mRenderDevice->EnumTextureFormats( D3DEnumPixelFormatsForBestMatchStaticCallback, this );
922
923 if( FAILED( hr ) || !mBestMatchFound )
924 return false;
925
926 *BestMatch = mBestMatchPixelFormat;
927 return true;
928 }
929
930 HRESULT UIDirect3DPrimaryCanvas::D3DEnumPixelFormatsForBestMatch( LPDDPIXELFORMAT lppf )
931 {
932 bool UseThisFormat = false;
933
934 if( mFormatToMatch.dwFlags & DDPF_FOURCC )
935 {
936 if( ( lppf->dwFlags & DDPF_FOURCC ) && (mFormatToMatch.dwFourCC == lppf->dwFourCC) )
937 UseThisFormat = true;
938 }
939 else
940 {
941 if( (mFormatToMatch.dwFlags & DDPF_ALPHAPIXELS) == (lppf->dwFlags & DDPF_ALPHAPIXELS) )
942 {
943 if( mFormatToMatch.dwRGBBitCount == lppf->dwRGBBitCount )
944 UseThisFormat = true;
945 }
946 }
947
948 if( UseThisFormat )
949 {
950 mBestMatchPixelFormat = *lppf;
951 mBestMatchFound = true;
952 return D3DENUMRET_CANCEL;
953 }
954 else
955 return D3DENUMRET_OK;
956 }
957
958 HRESULT CALLBACK UIDirect3DPrimaryCanvas::D3DEnumPixelFormatsForBestMatchStaticCallback( LPDDPIXELFORMAT lppf, LPVOID arg )
959 {
960 return reinterpret_cast<UIDirect3DPrimaryCanvas *>(arg)->D3DEnumPixelFormatsForBestMatch( lppf );
961 }
962
963 //----------------------------------------------------------------------
964
965 bool UIDirect3DPrimaryCanvas::GetShowShaders () const
966 {
967 return mShowShaders;
968 }
swg client tools