1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_canvas.hxx" 26 27 #if DIRECTX_VERSION == 0x0900 28 29 #define MAX_TEXTURE_SIZE (2048) 30 #define MIN_TEXTURE_SIZE (32) 31 //#define FAKE_MAX_NUMBER_TEXTURES (2) 32 //#define FAKE_MAX_TEXTURE_SIZE (4096) 33 34 #define VERTEX_BUFFER_SIZE (341*3) // 1023, the size of the internal 35 // vertex buffer (must be divisable 36 // by 3, as each triangle primitive 37 // has 3 vertices) 38 39 40 ////////////////////////////////////////////////////////////////////////////////// 41 // includes 42 ////////////////////////////////////////////////////////////////////////////////// 43 #include <vcl/syschild.hxx> 44 #include <vcl/window.hxx> 45 46 #include <canvas/debug.hxx> 47 #include <canvas/verbosetrace.hxx> 48 #include <tools/diagnose_ex.h> 49 50 #include <canvas/elapsedtime.hxx> 51 #include <canvas/canvastools.hxx> 52 #include <canvas/rendering/icolorbuffer.hxx> 53 #include <canvas/rendering/isurface.hxx> 54 #include <canvas/rendering/irendermodule.hxx> 55 #include <basegfx/numeric/ftools.hxx> 56 #include <basegfx/vector/b2dsize.hxx> 57 #include <basegfx/vector/b2isize.hxx> 58 #include <basegfx/point/b2ipoint.hxx> 59 #include <basegfx/range/b2irectangle.hxx> 60 #include <boost/scoped_ptr.hpp> 61 #include <com/sun/star/lang/NoSupportException.hpp> 62 63 #include "dx_rendermodule.hxx" 64 #include "dx_config.hxx" 65 66 #undef WB_LEFT 67 #undef WB_RIGHT 68 69 #include "dx_impltools.hxx" 70 #include <vcl/sysdata.hxx> 71 72 #if defined(DX_DEBUG_IMAGES) 73 # if OSL_DEBUG_LEVEL > 0 74 # include <imdebug.h> 75 # undef min 76 # undef max 77 # endif 78 #endif 79 80 using namespace ::com::sun::star; 81 82 ////////////////////////////////////////////////////////////////////////////////// 83 // 'dxcanvas' namespace 84 ////////////////////////////////////////////////////////////////////////////////// 85 86 namespace dxcanvas 87 { 88 namespace 89 { 90 ////////////////////////////////////////////////////////////////////////////////// 91 // monitorSupport 92 ////////////////////////////////////////////////////////////////////////////////// 93 94 class monitorSupport 95 { 96 public: 97 monitorSupport()98 monitorSupport() : 99 mhLibrary(LoadLibrary("user32.dll")), 100 mpMonitorFromWindow(NULL) 101 { 102 if(mhLibrary) 103 mpMonitorFromWindow = reinterpret_cast<fMonitorFromWindow>( 104 GetProcAddress( 105 mhLibrary,"MonitorFromWindow")); 106 } 107 ~monitorSupport()108 ~monitorSupport() 109 { 110 if(mhLibrary) 111 FreeLibrary(mhLibrary); 112 mhLibrary=0; 113 } 114 MonitorFromWindow(HWND hwnd)115 HMONITOR MonitorFromWindow( HWND hwnd ) 116 { 117 // return adapter_default in case something went wrong... 118 if(!(mpMonitorFromWindow)) 119 return HMONITOR(0); 120 // MONITOR_DEFAULTTONEAREST 121 const DWORD dwFlags(0x00000002); 122 return mpMonitorFromWindow(hwnd,dwFlags); 123 } 124 private: 125 126 HINSTANCE mhLibrary; 127 typedef HMONITOR (WINAPI *fMonitorFromWindow )( HWND hwnd, DWORD dwFlags ); 128 fMonitorFromWindow mpMonitorFromWindow; 129 }; 130 131 monitorSupport aMonitorSupport; 132 133 134 class DXRenderModule; 135 136 ////////////////////////////////////////////////////////////////////////////////// 137 // DXSurface 138 ////////////////////////////////////////////////////////////////////////////////// 139 140 /** ISurface implemenation. 141 142 @attention holds the DXRenderModule via non-refcounted 143 reference! This is safe with current state of affairs, since 144 the canvas::PageManager holds surface and render module via 145 shared_ptr (and makes sure all surfaces are deleted before its 146 render module member goes out of scope). 147 */ 148 class DXSurface : public canvas::ISurface 149 { 150 public: 151 DXSurface( DXRenderModule& rRenderModule, 152 const ::basegfx::B2ISize& rSize ); 153 ~DXSurface(); 154 155 virtual bool selectTexture(); 156 virtual bool isValid(); 157 virtual bool update( const ::basegfx::B2IPoint& rDestPos, 158 const ::basegfx::B2IRange& rSourceRect, 159 ::canvas::IColorBuffer& rSource ); 160 virtual ::basegfx::B2IVector getSize(); 161 COMReference<IDirect3DTexture9> getTexture() const; 162 163 private: 164 /// Guard local methods against concurrent acces to RenderModule 165 class ImplRenderModuleGuard : private ::boost::noncopyable 166 { 167 public: 168 explicit inline ImplRenderModuleGuard( DXRenderModule& rRenderModule ); 169 inline ~ImplRenderModuleGuard(); 170 171 private: 172 DXRenderModule& mrRenderModule; 173 }; 174 175 DXRenderModule& mrRenderModule; 176 COMReference<IDirect3DTexture9> mpTexture; 177 178 ::basegfx::B2IVector maSize; 179 }; 180 181 182 ////////////////////////////////////////////////////////////////////////////////// 183 // DXRenderModule 184 ////////////////////////////////////////////////////////////////////////////////// 185 186 /// Default implementation of IDXRenderModule 187 class DXRenderModule : public IDXRenderModule 188 { 189 public: 190 explicit DXRenderModule( const ::Window& rWindow ); 191 ~DXRenderModule(); 192 lock() const193 virtual void lock() const { maMutex.acquire(); } unlock() const194 virtual void unlock() const { maMutex.release(); } 195 196 virtual COMReference<IDirect3DSurface9> 197 createSystemMemorySurface( const ::basegfx::B2IVector& rSize ); 198 virtual void disposing(); getHWND() const199 virtual HWND getHWND() const { return mhWnd; } 200 virtual void screenShot(); 201 202 virtual bool flip( const ::basegfx::B2IRectangle& rUpdateArea, 203 const ::basegfx::B2IRectangle& rCurrWindowArea ); 204 205 virtual void resize( const ::basegfx::B2IRange& rect ); 206 virtual ::basegfx::B2IVector getPageSize(); 207 virtual ::canvas::ISurfaceSharedPtr createSurface( const ::basegfx::B2IVector& surfaceSize ); 208 virtual void beginPrimitive( PrimitiveType eType ); 209 virtual void endPrimitive(); 210 virtual void pushVertex( const ::canvas::Vertex& vertex ); 211 virtual bool isError(); 212 getDevice()213 COMReference<IDirect3DDevice9> getDevice() { return mpDevice; } 214 215 void flushVertexCache(); 216 void commitVertexCache(); 217 218 private: 219 220 bool create( const ::Window& rWindow ); 221 bool createDevice(); 222 bool verifyDevice( const UINT nAdapter ); 223 UINT getAdapterFromWindow(); 224 225 /** This object represents the DirectX state machine. In order 226 to serialize access to DirectX's global state, a global 227 mutex is required. 228 */ 229 static ::osl::Mutex maMutex; 230 231 HWND mhWnd; 232 COMReference<IDirect3DDevice9> mpDevice; 233 COMReference<IDirect3D9> mpDirect3D9; 234 COMReference<IDirect3DSwapChain9> mpSwapChain; 235 COMReference<IDirect3DVertexBuffer9> mpVertexBuffer; 236 ::canvas::ISurfaceSharedPtr mpTexture; 237 ::boost::scoped_ptr<SystemChildWindow> mpWindow; 238 ::basegfx::B2IVector maSize; 239 typedef std::vector<canvas::Vertex> vertexCache_t; 240 vertexCache_t maVertexCache; 241 std::size_t mnCount; 242 int mnBeginSceneCount; 243 bool mbCanUseDynamicTextures; 244 bool mbError; 245 PrimitiveType meType; 246 ::basegfx::B2IVector maPageSize; 247 D3DPRESENT_PARAMETERS mad3dpp; 248 isDisposed() const249 inline bool isDisposed() const { return (mhWnd==NULL); } 250 251 struct dxvertex 252 { 253 float x,y,z,rhw; 254 DWORD diffuse; 255 float u,v; 256 }; 257 258 std::size_t maNumVertices; 259 std::size_t maWriteIndex; 260 std::size_t maReadIndex; 261 }; 262 263 ::osl::Mutex DXRenderModule::maMutex; 264 265 ////////////////////////////////////////////////////////////////////////////////// 266 // DXSurface::ImplRenderModuleGuard 267 ////////////////////////////////////////////////////////////////////////////////// 268 ImplRenderModuleGuard(DXRenderModule & rRenderModule)269 inline DXSurface::ImplRenderModuleGuard::ImplRenderModuleGuard( 270 DXRenderModule& rRenderModule ) : 271 mrRenderModule( rRenderModule ) 272 { 273 mrRenderModule.lock(); 274 } 275 ~ImplRenderModuleGuard()276 inline DXSurface::ImplRenderModuleGuard::~ImplRenderModuleGuard() 277 { 278 mrRenderModule.unlock(); 279 } 280 281 #ifdef FAKE_MAX_NUMBER_TEXTURES 282 static sal_uInt32 gNumSurfaces = 0; 283 #endif 284 fillRect(sal_uInt32 * pDest,sal_uInt32 dwWidth,sal_uInt32 dwHeight,sal_uInt32 dwPitch,sal_uInt32 dwColor)285 void fillRect( sal_uInt32 *pDest, 286 sal_uInt32 dwWidth, 287 sal_uInt32 dwHeight, 288 sal_uInt32 dwPitch, 289 sal_uInt32 dwColor ) 290 { 291 for(sal_uInt32 i=0; i<dwWidth; ++i) 292 { 293 pDest[i]=dwColor; 294 pDest[((dwHeight-1)*dwPitch)+i]=dwColor; 295 } 296 297 for(sal_uInt32 j=0; j<dwHeight; ++j) 298 { 299 pDest[0]=dwColor; 300 pDest[dwWidth-1]=dwColor; 301 pDest += dwPitch; 302 } 303 } 304 305 ////////////////////////////////////////////////////////////////////////////////// 306 // DXSurface::DXSurface 307 ////////////////////////////////////////////////////////////////////////////////// 308 DXSurface(DXRenderModule & rRenderModule,const::basegfx::B2ISize & rSize)309 DXSurface::DXSurface( DXRenderModule& rRenderModule, 310 const ::basegfx::B2ISize& rSize ) : 311 mrRenderModule(rRenderModule), 312 mpTexture(NULL), 313 maSize() 314 { 315 ImplRenderModuleGuard aGuard( mrRenderModule ); 316 317 #ifdef FAKE_MAX_NUMBER_TEXTURES 318 ++gNumSurfaces; 319 if(gNumSurfaces >= FAKE_MAX_NUMBER_TEXTURES) 320 return; 321 #endif 322 323 #ifdef FAKE_MAX_TEXTURE_SIZE 324 if(rSize.getX() > FAKE_MAX_TEXTURE_SIZE) 325 return; 326 if(rSize.getY() > FAKE_MAX_TEXTURE_SIZE) 327 return; 328 #endif 329 330 ENSURE_ARG_OR_THROW(rSize.getX() > 0 && rSize.getY() > 0, 331 "DXSurface::DXSurface(): request for zero-sized surface"); 332 333 COMReference<IDirect3DDevice9> pDevice(rRenderModule.getDevice()); 334 335 IDirect3DTexture9 *pTexture(NULL); 336 if(FAILED(pDevice->CreateTexture( 337 rSize.getX(), 338 rSize.getY(), 339 1,0,D3DFMT_A8R8G8B8, 340 D3DPOOL_MANAGED, 341 &pTexture,NULL))) 342 return; 343 344 mpTexture=COMReference<IDirect3DTexture9>(pTexture); 345 maSize = rSize; 346 } 347 348 ////////////////////////////////////////////////////////////////////////////////// 349 // DXSurface::~DXSurface 350 ////////////////////////////////////////////////////////////////////////////////// 351 ~DXSurface()352 DXSurface::~DXSurface() 353 { 354 ImplRenderModuleGuard aGuard( mrRenderModule ); 355 356 #ifdef FAKE_MAX_NUMBER_TEXTURES 357 gNumSurfaces--; 358 #endif 359 } 360 361 ////////////////////////////////////////////////////////////////////////////////// 362 // DXSurface::selectTexture 363 ////////////////////////////////////////////////////////////////////////////////// 364 selectTexture()365 bool DXSurface::selectTexture() 366 { 367 ImplRenderModuleGuard aGuard( mrRenderModule ); 368 mrRenderModule.flushVertexCache(); 369 COMReference<IDirect3DDevice9> pDevice(mrRenderModule.getDevice()); 370 371 if( FAILED(pDevice->SetTexture(0,mpTexture.get())) ) 372 return false; 373 374 return true; 375 } 376 377 ////////////////////////////////////////////////////////////////////////////////// 378 // DXSurface::isValid 379 ////////////////////////////////////////////////////////////////////////////////// 380 isValid()381 bool DXSurface::isValid() 382 { 383 ImplRenderModuleGuard aGuard( mrRenderModule ); 384 385 if(!(mpTexture.is())) 386 return false; 387 return true; 388 } 389 390 ////////////////////////////////////////////////////////////////////////////////// 391 // DXSurface::update 392 ////////////////////////////////////////////////////////////////////////////////// 393 update(const::basegfx::B2IPoint & rDestPos,const::basegfx::B2IRange & rSourceRect,::canvas::IColorBuffer & rSource)394 bool DXSurface::update( const ::basegfx::B2IPoint& rDestPos, 395 const ::basegfx::B2IRange& rSourceRect, 396 ::canvas::IColorBuffer& rSource ) 397 { 398 ImplRenderModuleGuard aGuard( mrRenderModule ); 399 400 // can't update if surface is not valid, that means 401 // either not existent nor restored... 402 if(!(isValid())) 403 return false; 404 405 D3DLOCKED_RECT aLockedRect; 406 RECT rect; 407 rect.left = std::max(sal_Int32(0),rDestPos.getX()); 408 rect.top = std::max(sal_Int32(0),rDestPos.getY()); 409 // to avoid interpolation artifacts from other textures, 410 // the surface manager allocates one pixel gap between 411 // them. Clear that to transparent. 412 rect.right = std::min(maSize.getX(), 413 rect.left + sal_Int32(rSourceRect.getWidth()+1)); 414 rect.bottom = std::min(maSize.getY(), 415 rect.top + sal_Int32(rSourceRect.getHeight()+1)); 416 const bool bClearRightColumn( rect.right < maSize.getX() ); 417 const bool bClearBottomRow( rect.bottom < maSize.getY() ); 418 419 if(SUCCEEDED(mpTexture->LockRect(0,&aLockedRect,&rect,D3DLOCK_NOSYSLOCK))) 420 { 421 if(sal_uInt8* pImage = rSource.lock()) 422 { 423 switch( rSource.getFormat() ) 424 { 425 case ::canvas::IColorBuffer::FMT_A8R8G8B8: 426 { 427 const std::size_t nSourceBytesPerPixel(4); 428 const std::size_t nSourcePitchInBytes(rSource.getStride()); 429 pImage += rSourceRect.getMinY()*nSourcePitchInBytes; 430 pImage += rSourceRect.getMinX()*nSourceBytesPerPixel; 431 432 // calculate the destination memory address 433 sal_uInt8 *pDst = (sal_uInt8*)aLockedRect.pBits; 434 435 const sal_uInt32 nNumBytesToCopy( 436 static_cast<sal_uInt32>( 437 rSourceRect.getWidth())* 438 nSourceBytesPerPixel); 439 const sal_uInt64 nNumLines(rSourceRect.getHeight()); 440 441 for(sal_uInt32 i=0; i<nNumLines; ++i) 442 { 443 rtl_copyMemory(pDst,pImage,nNumBytesToCopy); 444 445 if( bClearRightColumn ) 446 { 447 // to avoid interpolation artifacts 448 // from other textures, the surface 449 // manager allocates one pixel gap 450 // between them. Clear that to 451 // transparent. 452 pDst[nNumBytesToCopy] = 453 pDst[nNumBytesToCopy+1] = 454 pDst[nNumBytesToCopy+2] = 455 pDst[nNumBytesToCopy+3] = 0x00; 456 } 457 pDst += aLockedRect.Pitch; 458 pImage += nSourcePitchInBytes; 459 } 460 461 if( bClearBottomRow ) 462 rtl_zeroMemory(pDst,nNumBytesToCopy+4); 463 } 464 break; 465 466 case ::canvas::IColorBuffer::FMT_R8G8B8: 467 { 468 const std::size_t nSourceBytesPerPixel(3); 469 const std::size_t nSourcePitchInBytes(rSource.getStride()); 470 pImage += rSourceRect.getMinY()*nSourcePitchInBytes; 471 pImage += rSourceRect.getMinX()*nSourceBytesPerPixel; 472 473 // calculate the destination memory address 474 sal_uInt8 *pDst = (sal_uInt8*)aLockedRect.pBits; 475 476 const sal_Int32 nNumColumns( 477 sal::static_int_cast<sal_Int32>(rSourceRect.getWidth())); 478 const sal_Int32 nNumLines( 479 sal::static_int_cast<sal_Int32>(rSourceRect.getHeight())); 480 for(sal_Int32 i=0; i<nNumLines; ++i) 481 { 482 sal_uInt32 *pDstScanline = reinterpret_cast<sal_uInt32 *>(pDst); 483 sal_uInt8 *pSrcScanline = reinterpret_cast<sal_uInt8 *>(pImage); 484 485 for(sal_Int32 x=0; x<nNumColumns; ++x) 486 { 487 sal_uInt32 color(0xFF000000); 488 color |= pSrcScanline[2]<<16; 489 color |= pSrcScanline[1]<<8; 490 color |= pSrcScanline[0]; 491 pSrcScanline += 3; 492 *pDstScanline++ = color; 493 } 494 if( bClearRightColumn ) 495 *pDstScanline++ = 0xFF000000; 496 497 pDst += aLockedRect.Pitch; 498 pImage += nSourcePitchInBytes; 499 } 500 501 if( bClearBottomRow ) 502 rtl_zeroMemory(pDst,4*(nNumColumns+1)); 503 } 504 break; 505 506 case ::canvas::IColorBuffer::FMT_X8R8G8B8: 507 { 508 const std::size_t nSourceBytesPerPixel(4); 509 const std::size_t nSourcePitchInBytes(rSource.getStride()); 510 pImage += rSourceRect.getMinY()*nSourcePitchInBytes; 511 pImage += rSourceRect.getMinX()*nSourceBytesPerPixel; 512 513 // calculate the destination memory address 514 sal_uInt8 *pDst = (sal_uInt8*)aLockedRect.pBits; 515 516 const sal_Int32 nNumLines( 517 sal::static_int_cast<sal_Int32>(rSourceRect.getHeight())); 518 const sal_Int32 nNumColumns( 519 sal::static_int_cast<sal_Int32>(rSourceRect.getWidth())); 520 for(sal_Int32 i=0; i<nNumLines; ++i) 521 { 522 sal_uInt32 *pSrc32 = reinterpret_cast<sal_uInt32 *>(pImage); 523 sal_uInt32 *pDst32 = reinterpret_cast<sal_uInt32 *>(pDst); 524 for(sal_Int32 j=0; j<nNumColumns; ++j) 525 pDst32[j] = 0xFF000000 | pSrc32[j]; 526 527 if( bClearRightColumn ) 528 pDst32[nNumColumns] = 0xFF000000; 529 530 pDst += aLockedRect.Pitch; 531 pImage += nSourcePitchInBytes; 532 } 533 534 if( bClearBottomRow ) 535 rtl_zeroMemory(pDst,4*(nNumColumns+1)); 536 } 537 break; 538 539 default: 540 ENSURE_OR_RETURN_FALSE(false, 541 "DXSurface::update(): Unknown/unimplemented buffer format" ); 542 break; 543 } 544 545 rSource.unlock(); 546 } 547 548 return SUCCEEDED(mpTexture->UnlockRect(0)); 549 } 550 551 return true; 552 } 553 554 ////////////////////////////////////////////////////////////////////////////////// 555 // DXSurface::getSize 556 ////////////////////////////////////////////////////////////////////////////////// 557 getSize()558 ::basegfx::B2IVector DXSurface::getSize() 559 { 560 return maSize; 561 } 562 getTexture() const563 COMReference<IDirect3DTexture9> DXSurface::getTexture() const 564 { 565 return mpTexture; 566 } 567 568 ////////////////////////////////////////////////////////////////////////////////// 569 // DXRenderModule::DXRenderModule 570 ////////////////////////////////////////////////////////////////////////////////// 571 DXRenderModule(const::Window & rWindow)572 DXRenderModule::DXRenderModule( const ::Window& rWindow ) : 573 mhWnd(0), 574 mpDevice(), 575 mpDirect3D9(), 576 mpSwapChain(), 577 mpVertexBuffer(), 578 mpTexture(), 579 maSize(), 580 maVertexCache(), 581 mnCount(0), 582 mnBeginSceneCount(0), 583 mbCanUseDynamicTextures(false), 584 mbError( false ), 585 meType( PRIMITIVE_TYPE_UNKNOWN ), 586 maPageSize(), 587 mad3dpp(), 588 maNumVertices( VERTEX_BUFFER_SIZE ), 589 maWriteIndex(0), 590 maReadIndex(0) 591 { 592 // TODO(P2): get rid of those fine-grained locking 593 ::osl::MutexGuard aGuard( maMutex ); 594 595 if(!(create(rWindow))) 596 { 597 throw lang::NoSupportException( 598 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( 599 "Could not create DirectX device!") ),NULL); 600 } 601 602 // allocate a single texture surface which can be used later. 603 // we also use this to calibrate the page size. 604 ::basegfx::B2IVector aPageSize(maPageSize); 605 while(true) 606 { 607 mpTexture = ::canvas::ISurfaceSharedPtr( 608 new DXSurface(*this,aPageSize)); 609 if(mpTexture->isValid()) 610 break; 611 612 aPageSize.setX(aPageSize.getX()>>1); 613 aPageSize.setY(aPageSize.getY()>>1); 614 if((aPageSize.getX() < MIN_TEXTURE_SIZE) || 615 (aPageSize.getY() < MIN_TEXTURE_SIZE)) 616 { 617 throw lang::NoSupportException( 618 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( 619 "Could not create DirectX device - " 620 "insufficient texture space!") ),NULL); 621 } 622 } 623 maPageSize=aPageSize; 624 625 IDirect3DVertexBuffer9 *pVB(NULL); 626 DWORD aFVF(D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1); 627 if( FAILED(mpDevice->CreateVertexBuffer(sizeof(dxvertex)*maNumVertices, 628 D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, 629 aFVF, 630 D3DPOOL_DEFAULT, 631 &pVB, 632 NULL)) ) 633 { 634 throw lang::NoSupportException( 635 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( 636 "Could not create DirectX device - out of memory!")),NULL); 637 } 638 639 mpVertexBuffer=COMReference<IDirect3DVertexBuffer9>(pVB); 640 } 641 642 ////////////////////////////////////////////////////////////////////////////////// 643 // DXRenderModule::~DXRenderModule 644 ////////////////////////////////////////////////////////////////////////////////// 645 ~DXRenderModule()646 DXRenderModule::~DXRenderModule() 647 { 648 disposing(); 649 } 650 651 ////////////////////////////////////////////////////////////////////////////////// 652 // DXRenderModule::disposing 653 ////////////////////////////////////////////////////////////////////////////////// 654 disposing()655 void DXRenderModule::disposing() 656 { 657 if(!(mhWnd)) 658 return; 659 660 mpTexture.reset(); 661 mpWindow.reset(); 662 mhWnd=NULL; 663 664 // refrain from releasing the DX9 objects. We're the only 665 // ones holding references to them, and it might be 666 // dangerous to destroy the DX9 device, before all other 667 // objects are dead. 668 } 669 670 ////////////////////////////////////////////////////////////////////////////////// 671 // DXRenderModule::create 672 ////////////////////////////////////////////////////////////////////////////////// 673 create(const::Window & rWindow)674 bool DXRenderModule::create( const ::Window& rWindow ) 675 { 676 // TODO(P2): get rid of those fine-grained locking 677 ::osl::MutexGuard aGuard( maMutex ); 678 679 maVertexCache.reserve(1024); 680 681 mpWindow.reset( 682 new SystemChildWindow( 683 const_cast<Window *>(&rWindow), 0) ); 684 685 // system child window must not receive mouse events 686 mpWindow->SetMouseTransparent( TRUE ); 687 688 // parent should receive paint messages as well 689 // [PARENTCLIPMODE_NOCLIP], the argument is here 690 // passed as plain numeric value since the stupid 691 // define utilizes a USHORT cast. 692 mpWindow->SetParentClipMode(0x0002); 693 694 // the system child window must not clear its background 695 mpWindow->EnableEraseBackground( sal_False ); 696 697 mpWindow->SetControlForeground(); 698 mpWindow->SetControlBackground(); 699 mpWindow->EnablePaint(sal_False); 700 701 const SystemEnvData *pData = mpWindow->GetSystemData(); 702 const HWND hwnd(reinterpret_cast<HWND>(pData->hWnd)); 703 mhWnd = const_cast<HWND>(hwnd); 704 705 ENSURE_OR_THROW( IsWindow( reinterpret_cast<HWND>(mhWnd) ), 706 "DXRenderModule::create() No valid HWND given." ); 707 708 // retrieve position and size of the parent window 709 const ::Size &rSizePixel(rWindow.GetSizePixel()); 710 711 // remember the size of the parent window, since we 712 // need to use this for our child window. 713 maSize.setX(static_cast<sal_Int32>(rSizePixel.Width())); 714 maSize.setY(static_cast<sal_Int32>(rSizePixel.Height())); 715 716 // let the child window cover the same size as the parent window. 717 mpWindow->SetPosSizePixel(0,0,maSize.getX(),maSize.getY()); 718 719 // TODO(F2): since we would like to share precious hardware 720 // resources, the direct3d9 object should be global. each new 721 // request for a canvas should only create a new swapchain. 722 mpDirect3D9 = COMReference<IDirect3D9>( 723 Direct3DCreate9(D3D_SDK_VERSION)); 724 if(!mpDirect3D9.is()) 725 return false; 726 727 // create a device from the direct3d9 object. 728 if(!(createDevice())) 729 return false; 730 731 mpWindow->Show(); 732 733 return true; 734 } 735 736 ////////////////////////////////////////////////////////////////////////////////// 737 // DXRenderModule::verifyDevice 738 ////////////////////////////////////////////////////////////////////////////////// 739 verifyDevice(const UINT nAdapter)740 bool DXRenderModule::verifyDevice( const UINT nAdapter ) 741 { 742 ENSURE_OR_THROW( mpDirect3D9.is(), 743 "DXRenderModule::verifyDevice() No valid device." ); 744 745 // ask direct3d9 about the capabilities of hardware devices on a specific adapter. 746 // here we decide if the underlying hardware of the machine 'is good enough'. 747 // since we only need a tiny little fraction of what could be used, this 748 // is basically a no-op. 749 D3DCAPS9 aCaps; 750 if(FAILED(mpDirect3D9->GetDeviceCaps(nAdapter,D3DDEVTYPE_HAL,&aCaps))) 751 return false; 752 if(!(aCaps.MaxTextureWidth)) 753 return false; 754 if(!(aCaps.MaxTextureHeight)) 755 return false; 756 maPageSize = ::basegfx::B2IVector(aCaps.MaxTextureWidth,aCaps.MaxTextureHeight); 757 758 // check device against white & blacklist entries 759 D3DADAPTER_IDENTIFIER9 aIdent; 760 if(FAILED(mpDirect3D9->GetAdapterIdentifier(nAdapter,0,&aIdent))) 761 return false; 762 763 DXCanvasItem aConfigItem; 764 DXCanvasItem::DeviceInfo aInfo; 765 aInfo.nVendorId = aIdent.VendorId; 766 aInfo.nDeviceId = aIdent.DeviceId; 767 aInfo.nDeviceSubSysId = aIdent.SubSysId; 768 aInfo.nDeviceRevision = aIdent.Revision; 769 770 aInfo.nDriverId = HIWORD(aIdent.DriverVersion.HighPart); 771 aInfo.nDriverVersion = LOWORD(aIdent.DriverVersion.HighPart); 772 aInfo.nDriverSubVersion = HIWORD(aIdent.DriverVersion.LowPart); 773 aInfo.nDriverBuildId = LOWORD(aIdent.DriverVersion.LowPart); 774 775 if( !aConfigItem.isDeviceUsable(aInfo) ) 776 return false; 777 778 if( aConfigItem.isBlacklistCurrentDevice() ) 779 { 780 aConfigItem.blacklistDevice(aInfo); 781 return false; 782 } 783 784 aConfigItem.adaptMaxTextureSize(maPageSize); 785 786 mbCanUseDynamicTextures = (aCaps.Caps2 & D3DCAPS2_DYNAMICTEXTURES) != 0; 787 788 return true; 789 } 790 791 792 ////////////////////////////////////////////////////////////////////////////////// 793 // DXRenderModule::createDevice 794 ////////////////////////////////////////////////////////////////////////////////// 795 createDevice()796 bool DXRenderModule::createDevice() 797 { 798 // we expect that the caller provides us with a valid HWND 799 ENSURE_OR_THROW( IsWindow(mhWnd), 800 "DXRenderModule::createDevice() No valid HWND given." ); 801 802 // we expect that the caller already created the direct3d9 object. 803 ENSURE_OR_THROW( mpDirect3D9.is(), 804 "DXRenderModule::createDevice() no direct3d?." ); 805 806 // find the adapter identifier from the window. 807 const UINT aAdapter(getAdapterFromWindow()); 808 if(aAdapter == static_cast<UINT>(-1)) 809 return false; 810 811 // verify that device possibly works 812 if( !verifyDevice(aAdapter) ) 813 return false; 814 815 // query the display mode from the selected adapter. 816 // we'll later request the backbuffer format to be same 817 // same as the display format. 818 D3DDISPLAYMODE d3ddm; 819 mpDirect3D9->GetAdapterDisplayMode(aAdapter,&d3ddm); 820 821 // we need to use D3DSWAPEFFECT_COPY here since the canvas-api has 822 // basically nothing to do with efficient resource handling. it tries 823 // to avoid drawing whenevery possible, which is simply not the most 824 // efficient way we could leverage the hardware in this case. it would 825 // be far better to redraw the backbuffer each time we would like to 826 // display the content of the backbuffer, but we need to face reality 827 // here and follow how the canvas was designed. 828 829 // Strictly speaking, we don't need a full screen worth of 830 // backbuffer here. We could also scale dynamically with 831 // the current window size, but this will make it 832 // necessary to temporarily have two buffers while copying 833 // from the old to the new one. What's more, at the time 834 // we need a larger buffer, DX might not have sufficient 835 // resources available, and we're then left with too small 836 // a back buffer, and no way of falling back to a 837 // different canvas implementation. 838 ZeroMemory( &mad3dpp, sizeof(mad3dpp) ); 839 mad3dpp.BackBufferWidth = std::max(sal_Int32(maSize.getX()), 840 sal_Int32(d3ddm.Width)); 841 mad3dpp.BackBufferHeight = std::max(sal_Int32(maSize.getY()), 842 sal_Int32(d3ddm.Height)); 843 mad3dpp.BackBufferCount = 1; 844 mad3dpp.Windowed = TRUE; 845 mad3dpp.SwapEffect = D3DSWAPEFFECT_COPY; 846 mad3dpp.BackBufferFormat = d3ddm.Format; 847 mad3dpp.EnableAutoDepthStencil = FALSE; 848 mad3dpp.hDeviceWindow = mhWnd; 849 mad3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; 850 851 // now create the device, first try hardware vertex processing, 852 // then software vertex processing. if both queries fail, we give up 853 // and indicate failure. 854 IDirect3DDevice9 *pDevice(NULL); 855 if(FAILED(mpDirect3D9->CreateDevice(aAdapter, 856 D3DDEVTYPE_HAL, 857 mhWnd, 858 D3DCREATE_HARDWARE_VERTEXPROCESSING| 859 D3DCREATE_MULTITHREADED|D3DCREATE_FPU_PRESERVE, 860 &mad3dpp, 861 &pDevice))) 862 if(FAILED(mpDirect3D9->CreateDevice(aAdapter, 863 D3DDEVTYPE_HAL, 864 mhWnd, 865 D3DCREATE_SOFTWARE_VERTEXPROCESSING| 866 D3DCREATE_MULTITHREADED|D3DCREATE_FPU_PRESERVE, 867 &mad3dpp, 868 &pDevice))) 869 return false; 870 871 // got it, store it in a safe place... 872 mpDevice=COMReference<IDirect3DDevice9>(pDevice); 873 874 // After CreateDevice, the first swap chain already exists, so just get it... 875 IDirect3DSwapChain9 *pSwapChain(NULL); 876 pDevice->GetSwapChain(0,&pSwapChain); 877 mpSwapChain=COMReference<IDirect3DSwapChain9>(pSwapChain); 878 if( !mpSwapChain.is() ) 879 return false; 880 881 // clear the render target [which is the backbuffer in this case]. 882 // we are forced to do this once, and furthermore right now. 883 // please note that this is only possible since we created the 884 // backbuffer with copy semantics [the content is preserved after 885 // calls to Present()], which is an unnecessarily expensive operation. 886 LPDIRECT3DSURFACE9 pBackBuffer = NULL; 887 mpSwapChain->GetBackBuffer(0,D3DBACKBUFFER_TYPE_MONO,&pBackBuffer); 888 mpDevice->SetRenderTarget( 0, pBackBuffer ); 889 mpDevice->Clear(0,NULL,D3DCLEAR_TARGET,0,1.0f,0L); 890 pBackBuffer->Release(); 891 892 return true; 893 } 894 895 ////////////////////////////////////////////////////////////////////////////////// 896 // DXRenderModule::createSystemMemorySurface 897 ////////////////////////////////////////////////////////////////////////////////// 898 createSystemMemorySurface(const::basegfx::B2IVector & rSize)899 COMReference<IDirect3DSurface9> DXRenderModule::createSystemMemorySurface( const ::basegfx::B2IVector& rSize ) 900 { 901 if(isDisposed()) 902 return COMReference<IDirect3DSurface9>(NULL); 903 904 // please note that D3DFMT_X8R8G8B8 is the only format we're 905 // able to choose here, since GetDC() doesn't support any 906 // other 32bit-format. 907 IDirect3DSurface9 *pSurface(NULL); 908 if( FAILED(mpDevice->CreateOffscreenPlainSurface( 909 rSize.getX(), 910 rSize.getY(), 911 D3DFMT_X8R8G8B8, 912 D3DPOOL_SYSTEMMEM, 913 &pSurface, 914 NULL)) ) 915 { 916 throw lang::NoSupportException( 917 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( 918 "Could not create offscreen surface - out of mem!") ),NULL); 919 } 920 921 return COMReference<IDirect3DSurface9>(pSurface); 922 } 923 924 ////////////////////////////////////////////////////////////////////////////////// 925 // DXRenderModule::flip 926 ////////////////////////////////////////////////////////////////////////////////// 927 flip(const::basegfx::B2IRectangle & rUpdateArea,const::basegfx::B2IRectangle &)928 bool DXRenderModule::flip( const ::basegfx::B2IRectangle& rUpdateArea, 929 const ::basegfx::B2IRectangle& /*rCurrWindowArea*/ ) 930 { 931 // TODO(P2): get rid of those fine-grained locking 932 ::osl::MutexGuard aGuard( maMutex ); 933 934 if(isDisposed() || !mpSwapChain.is()) 935 return false; 936 937 flushVertexCache(); 938 939 // TODO(P2): Might be faster to actually pass update area here 940 RECT aRect = 941 { 942 rUpdateArea.getMinX(), 943 rUpdateArea.getMinY(), 944 rUpdateArea.getMaxX(), 945 rUpdateArea.getMaxY() 946 }; 947 HRESULT hr(mpSwapChain->Present(&aRect,&aRect,NULL,NULL,0)); 948 if(FAILED(hr)) 949 { 950 if(hr != D3DERR_DEVICELOST) 951 return false; 952 953 // interestingly enough, sometimes the Reset() below 954 // *still* causes DeviceLost errors. So, cycle until 955 // DX was kind enough to really reset the device... 956 do 957 { 958 mpVertexBuffer.reset(); 959 hr = mpDevice->Reset(&mad3dpp); 960 if(SUCCEEDED(hr)) 961 { 962 IDirect3DVertexBuffer9 *pVB(NULL); 963 DWORD aFVF(D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1); 964 if( FAILED(mpDevice->CreateVertexBuffer(sizeof(dxvertex)*maNumVertices, 965 D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, 966 aFVF, 967 D3DPOOL_DEFAULT, 968 &pVB, 969 NULL)) ) 970 { 971 throw lang::NoSupportException( 972 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( 973 "Could not create DirectX device - out of memory!")),NULL); 974 } 975 mpVertexBuffer=COMReference<IDirect3DVertexBuffer9>(pVB); 976 977 // retry after the restore 978 if(SUCCEEDED(mpSwapChain->Present(&aRect,&aRect,NULL,NULL,0))) 979 return true; 980 } 981 982 TimeValue aTimeout; 983 aTimeout.Seconds=1; 984 aTimeout.Nanosec=0; 985 osl_waitThread(&aTimeout); 986 } 987 while(hr == D3DERR_DEVICELOST); 988 989 return false; 990 } 991 992 return true; 993 } 994 995 ////////////////////////////////////////////////////////////////////////////////// 996 // DXRenderModule::screenShot 997 ////////////////////////////////////////////////////////////////////////////////// 998 screenShot()999 void DXRenderModule::screenShot() 1000 { 1001 } 1002 1003 ////////////////////////////////////////////////////////////////////////////////// 1004 // DXRenderModule::resize 1005 ////////////////////////////////////////////////////////////////////////////////// 1006 resize(const::basegfx::B2IRange & rect)1007 void DXRenderModule::resize( const ::basegfx::B2IRange& rect ) 1008 { 1009 // TODO(P2): get rid of those fine-grained locking 1010 ::osl::MutexGuard aGuard( maMutex ); 1011 1012 if(isDisposed()) 1013 return; 1014 1015 // don't do anything if the size didn't change. 1016 if(maSize.getX() == static_cast<sal_Int32>(rect.getWidth()) && 1017 maSize.getY() == static_cast<sal_Int32>(rect.getHeight())) 1018 return; 1019 1020 // TODO(Q2): use numeric cast to prevent overflow 1021 maSize.setX(static_cast<sal_Int32>(rect.getWidth())); 1022 maSize.setY(static_cast<sal_Int32>(rect.getHeight())); 1023 1024 mpWindow->SetPosSizePixel(0,0,maSize.getX(),maSize.getY()); 1025 1026 // resize back buffer, if necessary 1027 // ------------------------------------------------------------- 1028 1029 // don't attempt to create anything if the 1030 // requested size is NULL. 1031 if(!(maSize.getX())) 1032 return; 1033 if(!(maSize.getY())) 1034 return; 1035 1036 // backbuffer too small (might happen, if window is 1037 // maximized across multiple monitors) 1038 if( sal_Int32(mad3dpp.BackBufferWidth) < maSize.getX() || 1039 sal_Int32(mad3dpp.BackBufferHeight) < maSize.getY() ) 1040 { 1041 mad3dpp.BackBufferWidth = maSize.getX(); 1042 mad3dpp.BackBufferHeight = maSize.getY(); 1043 1044 // clear before, save resources 1045 mpSwapChain.reset(); 1046 1047 IDirect3DSwapChain9 *pSwapChain(NULL); 1048 if(FAILED(mpDevice->CreateAdditionalSwapChain(&mad3dpp,&pSwapChain))) 1049 return; 1050 mpSwapChain=COMReference<IDirect3DSwapChain9>(pSwapChain); 1051 1052 // clear the render target [which is the backbuffer in this case]. 1053 // we are forced to do this once, and furthermore right now. 1054 // please note that this is only possible since we created the 1055 // backbuffer with copy semantics [the content is preserved after 1056 // calls to Present()], which is an unnecessarily expensive operation. 1057 LPDIRECT3DSURFACE9 pBackBuffer = NULL; 1058 mpSwapChain->GetBackBuffer(0,D3DBACKBUFFER_TYPE_MONO,&pBackBuffer); 1059 mpDevice->SetRenderTarget( 0, pBackBuffer ); 1060 mpDevice->Clear(0,NULL,D3DCLEAR_TARGET,0,1.0f,0L); 1061 pBackBuffer->Release(); 1062 } 1063 } 1064 1065 ////////////////////////////////////////////////////////////////////////////////// 1066 // DXRenderModule::getPageSize 1067 ////////////////////////////////////////////////////////////////////////////////// 1068 getPageSize()1069 ::basegfx::B2IVector DXRenderModule::getPageSize() 1070 { 1071 // TODO(P2): get rid of those fine-grained locking 1072 ::osl::MutexGuard aGuard( maMutex ); 1073 return maPageSize; 1074 } 1075 1076 ////////////////////////////////////////////////////////////////////////////////// 1077 // DXRenderModule::createSurface 1078 ////////////////////////////////////////////////////////////////////////////////// 1079 createSurface(const::basegfx::B2IVector & surfaceSize)1080 ::canvas::ISurfaceSharedPtr DXRenderModule::createSurface( const ::basegfx::B2IVector& surfaceSize ) 1081 { 1082 // TODO(P2): get rid of those fine-grained locking 1083 ::osl::MutexGuard aGuard( maMutex ); 1084 1085 if(isDisposed()) 1086 return ::canvas::ISurfaceSharedPtr(); 1087 1088 const ::basegfx::B2IVector& rPageSize( getPageSize() ); 1089 ::basegfx::B2ISize aSize(surfaceSize); 1090 if(!(aSize.getX())) 1091 aSize.setX(rPageSize.getX()); 1092 if(!(aSize.getY())) 1093 aSize.setY(rPageSize.getY()); 1094 1095 if(mpTexture.use_count() == 1) 1096 return mpTexture; 1097 1098 return ::canvas::ISurfaceSharedPtr( new DXSurface(*this,aSize) ); 1099 } 1100 1101 ////////////////////////////////////////////////////////////////////////////////// 1102 // DXRenderModule::beginPrimitive 1103 ////////////////////////////////////////////////////////////////////////////////// 1104 beginPrimitive(PrimitiveType eType)1105 void DXRenderModule::beginPrimitive( PrimitiveType eType ) 1106 { 1107 // TODO(P2): get rid of those fine-grained locking 1108 ::osl::MutexGuard aGuard( maMutex ); 1109 1110 if(isDisposed()) 1111 return; 1112 1113 ENSURE_OR_THROW( !mnBeginSceneCount, 1114 "DXRenderModule::beginPrimitive(): nested call" ); 1115 1116 ++mnBeginSceneCount; 1117 meType=eType; 1118 mnCount=0; 1119 } 1120 1121 ////////////////////////////////////////////////////////////////////////////////// 1122 // DXRenderModule::endPrimitive 1123 ////////////////////////////////////////////////////////////////////////////////// 1124 endPrimitive()1125 void DXRenderModule::endPrimitive() 1126 { 1127 // TODO(P2): get rid of those fine-grained locking 1128 ::osl::MutexGuard aGuard( maMutex ); 1129 1130 if(isDisposed()) 1131 return; 1132 1133 --mnBeginSceneCount; 1134 meType=PRIMITIVE_TYPE_UNKNOWN; 1135 mnCount=0; 1136 } 1137 1138 ////////////////////////////////////////////////////////////////////////////////// 1139 // DXRenderModule::pushVertex 1140 ////////////////////////////////////////////////////////////////////////////////// 1141 pushVertex(const::canvas::Vertex & vertex)1142 void DXRenderModule::pushVertex( const ::canvas::Vertex& vertex ) 1143 { 1144 // TODO(P2): get rid of those fine-grained locking 1145 ::osl::MutexGuard aGuard( maMutex ); 1146 1147 if(isDisposed()) 1148 return; 1149 1150 switch(meType) 1151 { 1152 case PRIMITIVE_TYPE_TRIANGLE: 1153 { 1154 maVertexCache.push_back(vertex); 1155 ++mnCount; 1156 mnCount &= 3; 1157 break; 1158 } 1159 1160 case PRIMITIVE_TYPE_QUAD: 1161 { 1162 if(mnCount == 3) 1163 { 1164 const std::size_t size(maVertexCache.size()); 1165 ::canvas::Vertex v0(maVertexCache[size-1]); 1166 ::canvas::Vertex v2(maVertexCache[size-3]); 1167 maVertexCache.push_back(v0); 1168 maVertexCache.push_back(vertex); 1169 maVertexCache.push_back(v2); 1170 mnCount=0; 1171 } 1172 else 1173 { 1174 maVertexCache.push_back(vertex); 1175 ++mnCount; 1176 } 1177 break; 1178 } 1179 1180 default: 1181 OSL_ENSURE(false, 1182 "DXRenderModule::pushVertex(): unexpected primitive type"); 1183 break; 1184 } 1185 } 1186 1187 ////////////////////////////////////////////////////////////////////////////////// 1188 // DXRenderModule::isError 1189 ////////////////////////////////////////////////////////////////////////////////// 1190 isError()1191 bool DXRenderModule::isError() 1192 { 1193 // TODO(P2): get rid of those fine-grained locking 1194 ::osl::MutexGuard aGuard( maMutex ); 1195 1196 return mbError; 1197 } 1198 1199 ////////////////////////////////////////////////////////////////////////////////// 1200 // DXRenderModule::getAdapterFromWindow 1201 ////////////////////////////////////////////////////////////////////////////////// 1202 getAdapterFromWindow()1203 UINT DXRenderModule::getAdapterFromWindow() 1204 { 1205 HMONITOR hMonitor(aMonitorSupport.MonitorFromWindow(mhWnd)); 1206 UINT aAdapterCount(mpDirect3D9->GetAdapterCount()); 1207 for(UINT i=0; i<aAdapterCount; ++i) 1208 if(hMonitor == mpDirect3D9->GetAdapterMonitor(i)) 1209 return i; 1210 return static_cast<UINT>(-1); 1211 } 1212 1213 ////////////////////////////////////////////////////////////////////////////////// 1214 // DXRenderModule::commitVertexCache 1215 ////////////////////////////////////////////////////////////////////////////////// 1216 commitVertexCache()1217 void DXRenderModule::commitVertexCache() 1218 { 1219 if(maReadIndex != maWriteIndex) 1220 { 1221 const std::size_t nVertexStride = sizeof(dxvertex); 1222 const unsigned int nNumVertices = maWriteIndex-maReadIndex; 1223 const unsigned int nNumPrimitives = nNumVertices / 3; 1224 1225 if(FAILED(mpDevice->SetStreamSource(0,mpVertexBuffer.get(),0,nVertexStride))) 1226 return; 1227 1228 if(FAILED(mpDevice->SetFVF(D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1))) 1229 return; 1230 1231 if(FAILED(mpDevice->BeginScene())) 1232 return; 1233 1234 mbError |= FAILED(mpDevice->DrawPrimitive(D3DPT_TRIANGLELIST,maReadIndex,nNumPrimitives)); 1235 mbError |= FAILED(mpDevice->EndScene()); 1236 1237 maReadIndex += nNumVertices; 1238 } 1239 } 1240 1241 ////////////////////////////////////////////////////////////////////////////////// 1242 // DXRenderModule::flushVertexCache 1243 ////////////////////////////////////////////////////////////////////////////////// 1244 flushVertexCache()1245 void DXRenderModule::flushVertexCache() 1246 { 1247 if(!(maVertexCache.size())) 1248 return; 1249 1250 mbError=true; 1251 1252 if( FAILED(mpDevice->SetRenderState(D3DRS_LIGHTING,FALSE))) 1253 return; 1254 1255 // enable texture alpha blending 1256 if( FAILED(mpDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE))) 1257 return; 1258 1259 mpDevice->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_LINEAR); 1260 mpDevice->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_LINEAR); 1261 mpDevice->SetSamplerState(0,D3DSAMP_ADDRESSU ,D3DTADDRESS_CLAMP ); 1262 mpDevice->SetSamplerState(0,D3DSAMP_ADDRESSV ,D3DTADDRESS_CLAMP ); 1263 1264 // configure the fixed-function pipeline. 1265 // the only 'feature' we need here is to modulate the alpha-channels 1266 // from the texture and the interpolated diffuse color. the result 1267 // will then be blended with the backbuffer. 1268 // fragment color = texture color * diffuse.alpha. 1269 mpDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_MODULATE); 1270 mpDevice->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE); 1271 mpDevice->SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE); 1272 1273 // normal combination of object... 1274 if( FAILED(mpDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA)) ) 1275 return; 1276 1277 // ..and background color 1278 if( FAILED(mpDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA)) ) 1279 return; 1280 1281 // disable backface culling; this enables us to mirror sprites 1282 // by simply reverting the triangles, which, with enabled 1283 // culling, would be invisible otherwise 1284 if( FAILED(mpDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE)) ) 1285 return; 1286 1287 mbError=false; 1288 1289 std::size_t nSize(maVertexCache.size()); 1290 const std::size_t nVertexStride = sizeof(dxvertex); 1291 1292 const ::basegfx::B2IVector aPageSize(getPageSize()); 1293 const float nHalfPixelSizeX(0.5f/aPageSize.getX()); 1294 const float nHalfPixelSizeY(0.5f/aPageSize.getY()); 1295 vertexCache_t::const_iterator it(maVertexCache.begin()); 1296 1297 while( nSize ) 1298 { 1299 DWORD dwLockFlags(D3DLOCK_NOOVERWRITE); 1300 1301 // Check to see if there's space for the current set of 1302 // vertices in the buffer. 1303 if( maNumVertices - maWriteIndex < nSize ) 1304 { 1305 commitVertexCache(); 1306 dwLockFlags = D3DLOCK_DISCARD; 1307 maWriteIndex = 0; 1308 maReadIndex = 0; 1309 } 1310 1311 dxvertex *vertices(NULL); 1312 const std::size_t nNumVertices( 1313 std::min(maNumVertices - maWriteIndex, 1314 nSize)); 1315 if(FAILED(mpVertexBuffer->Lock(maWriteIndex*nVertexStride, 1316 nNumVertices*nVertexStride, 1317 (void **)&vertices, 1318 dwLockFlags))) 1319 return; 1320 1321 std::size_t nIndex(0); 1322 while( nIndex < nNumVertices ) 1323 { 1324 dxvertex &dest = vertices[nIndex++]; 1325 dest.x=it->x; 1326 dest.y=it->y; 1327 dest.z=it->z; 1328 dest.rhw=1; 1329 const sal_uInt32 alpha(static_cast<sal_uInt32>(it->a*255.0f)); 1330 dest.diffuse=D3DCOLOR_ARGB(alpha,255,255,255); 1331 dest.u=static_cast<float>(it->u + nHalfPixelSizeX); 1332 dest.v=static_cast<float>(it->v + nHalfPixelSizeY); 1333 ++it; 1334 } 1335 1336 mpVertexBuffer->Unlock(); 1337 1338 // Advance to the next position in the vertex buffer. 1339 maWriteIndex += nNumVertices; 1340 nSize -= nNumVertices; 1341 1342 commitVertexCache(); 1343 } 1344 1345 maVertexCache.clear(); 1346 } 1347 } 1348 1349 ////////////////////////////////////////////////////////////////////////////////// 1350 // createRenderModule 1351 ////////////////////////////////////////////////////////////////////////////////// 1352 createRenderModule(const::Window & rParent)1353 IDXRenderModuleSharedPtr createRenderModule( const ::Window& rParent ) 1354 { 1355 return IDXRenderModuleSharedPtr( new DXRenderModule(rParent) ); 1356 } 1357 } 1358 1359 #endif 1360