Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

d3d9renderer.cpp

Go to the documentation of this file.
00001 /************************************************************************
00002         filename:       d3d9renderer.cpp
00003         created:        17/7/2004
00004         author:         Paul D Turner with D3D 9 Updates by Magnus Österlind
00005         
00006         purpose:        Main source file for Renderer class using DirectX 9.0
00007 *************************************************************************/
00008 /*************************************************************************
00009     Crazy Eddie's GUI System (http://www.cegui.org.uk)
00010     Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
00011 
00012     This library is free software; you can redistribute it and/or
00013     modify it under the terms of the GNU Lesser General Public
00014     License as published by the Free Software Foundation; either
00015     version 2.1 of the License, or (at your option) any later version.
00016 
00017     This library is distributed in the hope that it will be useful,
00018     but WITHOUT ANY WARRANTY; without even the implied warranty of
00019     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00020     Lesser General Public License for more details.
00021 
00022     You should have received a copy of the GNU Lesser General Public
00023     License along with this library; if not, write to the Free Software
00024     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00025 *************************************************************************/
00026 #include "renderers/directx9GUIRenderer/d3d9renderer.h"
00027 #include "renderers/directx9GUIRenderer/d3d9texture.h"
00028 #include "CEGUIExceptions.h"
00029 #include "CEGUISystem.h"
00030 
00031 #include <d3dx9.h>
00032 #include <dxerr9.h>
00033 #include <algorithm>
00034 #undef min
00035 
00036 // Start of CEGUI namespace section
00037 namespace CEGUI
00038 {
00039 /*************************************************************************
00040         Constants definitions
00041 *************************************************************************/
00042 const int                       DirectX9Renderer::VERTEX_PER_QUAD                       = 6;
00043 const int                       DirectX9Renderer::VERTEX_PER_TRIANGLE           = 3;
00044 const int                       DirectX9Renderer::VERTEXBUFFER_CAPACITY = 4096;
00045 const ulong                     DirectX9Renderer::VERTEX_FVF                            = (D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1);
00046 
00047 
00048 /*************************************************************************
00049         Constructor
00050 *************************************************************************/
00051 DirectX9Renderer::DirectX9Renderer(LPDIRECT3DDEVICE9 device, uint max_quads)
00052 {
00053         d_device = device;
00054         Size size(getViewportSize());
00055 
00056         constructor_impl(device, size);
00057 }
00058 
00059 
00060 /*************************************************************************
00061         method to do work of constructor
00062 *************************************************************************/
00063 void DirectX9Renderer::constructor_impl(LPDIRECT3DDEVICE9 device, const Size& display_size)
00064 {
00065         d_device        = device;
00066         d_queueing      = true;
00067         d_currTexture   = NULL;
00068         d_buffer        = NULL;
00069         d_bufferPos     = 0;
00070 
00071         // initialise renderer display area
00072         d_display_area.d_left   = 0;
00073         d_display_area.d_top    = 0;
00074         d_display_area.setSize(display_size);
00075 
00076         // Create a vertex buffer
00077         if (FAILED(d_device->CreateVertexBuffer(
00078                 (VERTEXBUFFER_CAPACITY * sizeof(QuadVertex)), 
00079                 D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, 
00080                 VERTEX_FVF, 
00081                 D3DPOOL_DEFAULT, 
00082                 &d_buffer,
00083                 NULL)))
00084         {
00085                 // Ideally, this would have been a RendererException, but we can't use that until the System object is created
00086                 // and that requires a Renderer passed to the constructor, so we throw this instead.
00087                 throw std::exception("Creation of VertexBuffer for Renderer object failed");
00088         }
00089 
00090         // get the maximum available texture size.
00091         D3DCAPS9        devCaps;
00092         if (FAILED(device->GetDeviceCaps(&devCaps)))
00093         {
00094                 // release vertex buffer
00095                 d_buffer->Release();
00096                 throw std::exception("Unable to retrieve device capabilities from Direct3DDevice9.");
00097         }
00098 
00099         // set max texture size the the smaller of max width and max height.
00100         d_maxTextureSize = ceguimin(devCaps.MaxTextureWidth, devCaps.MaxTextureHeight);
00101 
00102         d_device->AddRef();
00103 }
00104 
00105 
00106 /*************************************************************************
00107         Destructor
00108 *************************************************************************/
00109 DirectX9Renderer::~DirectX9Renderer(void)
00110 {
00111         if (d_buffer != NULL)
00112         {
00113                 d_buffer->Release();
00114         }
00115 
00116         destroyAllTextures();
00117 
00118         if (d_device != NULL)
00119         {
00120                 d_device->Release();
00121         }
00122 }
00123 
00124 
00125 /*************************************************************************
00126         add's a quad to the list to be rendered
00127 *************************************************************************/
00128 void DirectX9Renderer::addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode)
00129 {
00130         // if not queueing, render directly (as in, right now!)
00131         if (!d_queueing)
00132         {
00133                 renderQuadDirect(dest_rect, z, tex, texture_rect, colours, quad_split_mode);
00134         }
00135         else
00136         {
00137                 QuadInfo quad;
00138 
00139                 quad.position           = dest_rect;
00140                 quad.z                          = z;
00141                 quad.texture            = ((DirectX9Texture*)tex)->getD3DTexture();
00142                 quad.texPosition        = texture_rect;
00143                 quad.topLeftCol         = colours.d_top_left.getARGB();
00144                 quad.topRightCol        = colours.d_top_right.getARGB();
00145                 quad.bottomLeftCol      = colours.d_bottom_left.getARGB();
00146                 quad.bottomRightCol     = colours.d_bottom_right.getARGB();
00147 
00148                 // offset destination to get correct texel to pixel mapping from Direct3D
00149                 quad.position.offset(Point(-0.5f, -0.5f));
00150 
00151         // set quad split mode
00152         quad.splitMode = quad_split_mode;
00153 
00154                 d_quadlist.insert(quad);
00155         }
00156 
00157 }
00158 
00159 
00160 /*************************************************************************
00161         perform final rendering for all queued renderable quads.
00162 *************************************************************************/
00163 void DirectX9Renderer::doRender(void)
00164 {
00165         d_currTexture = NULL;
00166 
00167         initPerFrameStates();
00168 
00169         bool locked = false;
00170         QuadVertex*     buffmem;
00171 
00172         // iterate over each quad in the list
00173         for (QuadList::iterator i = d_quadlist.begin(); i != d_quadlist.end(); ++i)
00174         {
00175                 const QuadInfo& quad = (*i);
00176 
00177                 // flush & set texture if needed
00178                 if (d_currTexture != quad.texture)
00179                 {
00180                         if (locked)
00181                         {
00182                                 d_buffer->Unlock();
00183                                 locked = false;
00184                         }
00185 
00186                         // render any remaining quads for current texture
00187                         renderVBuffer();
00188 
00189                         // set new texture
00190                         d_device->SetTexture(0, quad.texture);
00191                         d_currTexture = quad.texture;
00192                 }
00193 
00194                 if (!locked)
00195                 {
00196                         if (FAILED(d_buffer->Lock(0, 0, (void**)&buffmem, D3DLOCK_DISCARD)))
00197                         {
00198                                 return;
00199                         }
00200 
00201                         locked = true;
00202                 }
00203 
00204                 // setup Vertex 1...
00205                 buffmem->x = quad.position.d_left;
00206                 buffmem->y = quad.position.d_top;
00207                 buffmem->z = quad.z;
00208                 buffmem->rhw = 1.0f;
00209                 buffmem->diffuse = quad.topLeftCol;
00210                 buffmem->tu1 = quad.texPosition.d_left;
00211                 buffmem->tv1 = quad.texPosition.d_top;
00212                 ++buffmem;
00213 
00214                 // setup Vertex 2...
00215 
00216         // top-left to bottom-right diagonal
00217         if (quad.splitMode == TopLeftToBottomRight)
00218         {
00219             buffmem->x = quad.position.d_right;
00220             buffmem->y = quad.position.d_bottom;
00221             buffmem->z = quad.z;
00222             buffmem->rhw = 1.0f;
00223             buffmem->diffuse = quad.bottomRightCol;
00224             buffmem->tu1 = quad.texPosition.d_right;
00225             buffmem->tv1 = quad.texPosition.d_bottom;
00226         }
00227         // bottom-left to top-right diagonal
00228         else
00229         {
00230             buffmem->x = quad.position.d_right;
00231             buffmem->y = quad.position.d_top;
00232             buffmem->z = quad.z;
00233             buffmem->rhw = 1.0f;
00234             buffmem->diffuse = quad.topRightCol;
00235             buffmem->tu1 = quad.texPosition.d_right;
00236             buffmem->tv1 = quad.texPosition.d_top;
00237         }
00238         ++buffmem;
00239 
00240                 // setup Vertex 3...
00241                 buffmem->x = quad.position.d_left;
00242                 buffmem->y = quad.position.d_bottom;
00243                 buffmem->z = quad.z;
00244                 buffmem->rhw = 1.0f;
00245                 buffmem->diffuse = quad.bottomLeftCol;
00246                 buffmem->tu1 = quad.texPosition.d_left;
00247                 buffmem->tv1 = quad.texPosition.d_bottom;
00248                 ++buffmem;
00249 
00250                 // setup Vertex 4...
00251                 buffmem->x = quad.position.d_right;
00252                 buffmem->y = quad.position.d_top;
00253                 buffmem->z = quad.z;
00254                 buffmem->rhw = 1.0f;
00255                 buffmem->diffuse = quad.topRightCol;
00256                 buffmem->tu1 = quad.texPosition.d_right;
00257                 buffmem->tv1 = quad.texPosition.d_top;
00258                 ++buffmem;
00259 
00260                 // setup Vertex 5...
00261                 buffmem->x = quad.position.d_right;
00262                 buffmem->y = quad.position.d_bottom;
00263                 buffmem->z = quad.z;
00264                 buffmem->rhw = 1.0f;
00265                 buffmem->diffuse = quad.bottomRightCol;
00266                 buffmem->tu1 = quad.texPosition.d_right;
00267                 buffmem->tv1 = quad.texPosition.d_bottom;
00268                 ++buffmem;
00269 
00270                 // setup Vertex 6...
00271 
00272         // top-left to bottom-right diagonal
00273         if (quad.splitMode == TopLeftToBottomRight)
00274         {
00275             buffmem->x = quad.position.d_left;
00276             buffmem->y = quad.position.d_top;
00277             buffmem->z = quad.z;
00278             buffmem->rhw = 1.0f;
00279             buffmem->diffuse = quad.topLeftCol;
00280             buffmem->tu1 = quad.texPosition.d_left;
00281             buffmem->tv1 = quad.texPosition.d_top;
00282         }
00283         // bottom-left to top-right diagonal
00284         else
00285         {
00286             buffmem->x = quad.position.d_left;
00287             buffmem->y = quad.position.d_bottom;
00288             buffmem->z = quad.z;
00289             buffmem->rhw = 1.0f;
00290             buffmem->diffuse = quad.bottomLeftCol;
00291             buffmem->tu1 = quad.texPosition.d_left;
00292             buffmem->tv1 = quad.texPosition.d_bottom;
00293         }
00294         ++buffmem;
00295 
00296                 // update buffer level
00297                 d_bufferPos += VERTEX_PER_QUAD;
00298 
00299                 // if there is not enough room in the buffer for another sprite, render what we have
00300                 if (d_bufferPos >= (VERTEXBUFFER_CAPACITY - VERTEX_PER_QUAD))
00301                 {
00302                         if (locked)
00303                         {
00304                                 d_buffer->Unlock();
00305                                 locked = false;
00306                         }
00307 
00308                         renderVBuffer();
00309                 }
00310 
00311         }
00312 
00313         if (locked)
00314         {
00315                 d_buffer->Unlock();
00316                 locked = false;
00317         }
00318 
00319         renderVBuffer();
00320 }
00321 
00322 
00323 /*************************************************************************
00324         clear the queue
00325 *************************************************************************/
00326 void DirectX9Renderer::clearRenderList(void)
00327 {
00328         d_quadlist.clear();
00329 }
00330 
00331 
00332 /*************************************************************************
00333         create an empty texture
00334 *************************************************************************/
00335 Texture* DirectX9Renderer::createTexture(void)
00336 {
00337         DirectX9Texture* tex = new DirectX9Texture(this);
00338         d_texturelist.push_back(tex);
00339         return tex;
00340 }
00341 
00342 
00343 /*************************************************************************
00344         Create a new Texture object and load a file into it.
00345 *************************************************************************/
00346 Texture* DirectX9Renderer::createTexture(const String& filename, const String& resourceGroup)
00347 {
00348         DirectX9Texture* tex = (DirectX9Texture*)createTexture();
00349         tex->loadFromFile(filename, resourceGroup);
00350 
00351         return tex;
00352 }
00353 
00354 
00355 /*************************************************************************
00356         Create a new texture with the given dimensions
00357 *************************************************************************/
00358 Texture* DirectX9Renderer::createTexture(float size)
00359 {
00360         DirectX9Texture* tex = (DirectX9Texture*)createTexture();
00361         tex->setD3DTextureSize((uint)size);
00362 
00363         return tex;
00364 }
00365 
00366 /*************************************************************************
00367         Destroy a texture
00368 *************************************************************************/
00369 void DirectX9Renderer::destroyTexture(Texture* texture)
00370 {
00371         if (texture != NULL)
00372         {
00373                 DirectX9Texture* tex = (DirectX9Texture*)texture;
00374                 d_texturelist.remove(tex);
00375                 delete tex;
00376         }
00377 
00378 }
00379 
00380 
00381 /*************************************************************************
00382         destroy all textures still active
00383 *************************************************************************/
00384 void DirectX9Renderer::destroyAllTextures(void)
00385 {
00386         while (!d_texturelist.empty())
00387         {
00388                 destroyTexture(*(d_texturelist.begin()));
00389         }
00390 }
00391 
00392 
00393 /*************************************************************************
00394         setup states etc
00395 *************************************************************************/
00396 void DirectX9Renderer::initPerFrameStates(void)
00397 {
00398         // setup vertex stream
00399         d_device->SetStreamSource(0, d_buffer, 0, sizeof(QuadVertex));
00400         d_device->SetFVF(VERTEX_FVF);
00401         d_device->SetVertexShader( NULL );
00402         d_device->SetPixelShader( NULL );
00403 
00404         // set device states
00405         d_device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
00406         d_device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
00407         d_device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
00408         d_device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
00409         d_device->SetRenderState(D3DRS_FOGENABLE, FALSE);
00410 
00411 
00412         // setup texture addressing settings
00413         d_device->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
00414         d_device->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
00415 
00416         // setup colour calculations
00417         d_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
00418         d_device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
00419         d_device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
00420 
00421         // setup alpha calculations
00422         d_device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
00423         d_device->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
00424         d_device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
00425 
00426         // setup filtering
00427         d_device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
00428         d_device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
00429 
00430         // setup scene alpha blending
00431         d_device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
00432         d_device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
00433         d_device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
00434 }
00435 
00436 
00437 /*************************************************************************
00438         renders whatever is in the vertex buffer
00439 *************************************************************************/
00440 void DirectX9Renderer::renderVBuffer(void)
00441 {
00442         // if bufferPos is 0 there is no data in the buffer and nothing to render
00443         if (d_bufferPos == 0)
00444         {
00445                 return;
00446         }
00447 
00448         // render the sprites
00449         d_device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, (d_bufferPos / VERTEX_PER_TRIANGLE));
00450 
00451         // reset buffer position to 0...
00452         d_bufferPos = 0;
00453 }
00454 
00455 
00456 /*************************************************************************
00457         sort quads list according to texture
00458 *************************************************************************/
00459 void DirectX9Renderer::sortQuads(void)
00460 {
00461 }
00462 
00463 
00464 /*************************************************************************
00465         render a quad directly to the display
00466 *************************************************************************/
00467 void DirectX9Renderer::renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode)
00468 {
00469         // ensure offset destination to ensure proper texel to pixel mapping from D3D.
00470         Rect final_rect(dest_rect);
00471         final_rect.offset(Point(-0.5f, -0.5f));
00472 
00473         QuadVertex*     buffmem;
00474 
00475         initPerFrameStates();
00476         d_device->SetTexture(0, ((DirectX9Texture*)tex)->getD3DTexture());
00477 
00478         if (SUCCEEDED(d_buffer->Lock(0, VERTEX_PER_QUAD * sizeof(QuadVertex), (void**)&buffmem, D3DLOCK_DISCARD)))
00479         {
00480                 // setup Vertex 1...
00481                 buffmem->x = final_rect.d_left;
00482                 buffmem->y = final_rect.d_top;
00483                 buffmem->z = z;
00484                 buffmem->rhw = 1.0f;
00485                 buffmem->diffuse = colours.d_top_left.getARGB();
00486                 buffmem->tu1 = texture_rect.d_left;
00487                 buffmem->tv1 = texture_rect.d_top;
00488                 ++buffmem;
00489 
00490         // setup Vertex 2...
00491 
00492         // top-left to bottom-right diagonal
00493         if (quad_split_mode == TopLeftToBottomRight)
00494         {
00495             buffmem->x = final_rect.d_right;
00496             buffmem->y = final_rect.d_bottom;
00497             buffmem->z = z;
00498             buffmem->rhw = 1.0f;
00499             buffmem->diffuse = colours.d_bottom_right.getARGB();
00500             buffmem->tu1 = texture_rect.d_right;
00501             buffmem->tv1 = texture_rect.d_bottom;
00502         }
00503         // bottom-left to top-right diagonal
00504         else
00505         {
00506             buffmem->x = final_rect.d_right;
00507             buffmem->y = final_rect.d_top;
00508             buffmem->z = z;
00509             buffmem->rhw = 1.0f;
00510             buffmem->diffuse = colours.d_top_right.getARGB();
00511             buffmem->tu1 = texture_rect.d_right;
00512             buffmem->tv1 = texture_rect.d_top;
00513         }
00514         ++buffmem;
00515 
00516                 // setup Vertex 3...
00517                 buffmem->x = final_rect.d_left;
00518                 buffmem->y = final_rect.d_bottom;
00519                 buffmem->z = z;
00520                 buffmem->rhw = 1.0f;
00521                 buffmem->diffuse = colours.d_bottom_left.getARGB();
00522                 buffmem->tu1 = texture_rect.d_left;
00523                 buffmem->tv1 = texture_rect.d_bottom;
00524                 ++buffmem;
00525 
00526                 // setup Vertex 4...
00527                 buffmem->x = final_rect.d_right;
00528                 buffmem->y = final_rect.d_top;
00529                 buffmem->z = z;
00530                 buffmem->rhw = 1.0f;
00531                 buffmem->diffuse = colours.d_top_right.getARGB();
00532                 buffmem->tu1 = texture_rect.d_right;
00533                 buffmem->tv1 = texture_rect.d_top;
00534                 ++buffmem;
00535 
00536                 // setup Vertex 5...
00537                 buffmem->x = final_rect.d_right;
00538                 buffmem->y = final_rect.d_bottom;
00539                 buffmem->z = z;
00540                 buffmem->rhw = 1.0f;
00541                 buffmem->diffuse = colours.d_bottom_right.getARGB();
00542                 buffmem->tu1 = texture_rect.d_right;
00543                 buffmem->tv1 = texture_rect.d_bottom;
00544                 ++buffmem;
00545 
00546                 // setup Vertex 6...
00547 
00548         // top-left to bottom-right diagonal
00549         if (quad_split_mode == TopLeftToBottomRight)
00550         {
00551             buffmem->x = final_rect.d_left;
00552             buffmem->y = final_rect.d_top;
00553             buffmem->z = z;
00554             buffmem->rhw = 1.0f;
00555             buffmem->diffuse = colours.d_top_left.getARGB();
00556             buffmem->tu1 = texture_rect.d_left;
00557             buffmem->tv1 = texture_rect.d_top;
00558         }
00559         // bottom-left to top-right diagonal
00560         else
00561         {
00562             buffmem->x = final_rect.d_left;
00563             buffmem->y = final_rect.d_bottom;
00564             buffmem->z = z;
00565             buffmem->rhw = 1.0f;
00566             buffmem->diffuse = colours.d_bottom_left.getARGB();
00567             buffmem->tu1 = texture_rect.d_left;
00568             buffmem->tv1 = texture_rect.d_bottom;
00569         }
00570 
00571                 d_buffer->Unlock();
00572                 d_bufferPos = VERTEX_PER_QUAD;
00573 
00574                 renderVBuffer();
00575         }
00576 
00577 }
00578 
00579 
00580 /*************************************************************************
00581         Direct3D support method that must be called prior to a Reset call
00582         on the Direct3DDevice.
00583 *************************************************************************/
00584 void DirectX9Renderer::preD3DReset(void)
00585 {
00586         // release the buffer prior to the reset call (will be re-created later)
00587         if (FAILED(d_buffer->Release()))
00588         {
00589                 throw RendererException("DirectX9Renderer::preD3DReset - Failed to release the VertexBuffer used by the DirectX9Renderer object.");
00590         }
00591 
00592         d_buffer = 0;
00593 
00594         // perform pre-reset operations on all textures
00595         std::list<DirectX9Texture*>::iterator ctex = d_texturelist.begin();
00596         std::list<DirectX9Texture*>::iterator endtex = d_texturelist.end();
00597 
00598         for (; ctex != endtex; ++ctex)
00599         {
00600                 (*ctex)->preD3DReset();
00601         }
00602 
00603 }
00604 
00605 
00606 /*************************************************************************
00607         Direct3D support method that must be called after a Reset call on the
00608         Direct3DDevice.
00609 *************************************************************************/
00610 void DirectX9Renderer::postD3DReset(void)
00611 {
00612         // Recreate a vertex buffer
00613         if (FAILED(d_device->CreateVertexBuffer((VERTEXBUFFER_CAPACITY * sizeof(QuadVertex)), D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, VERTEX_FVF, D3DPOOL_DEFAULT, &d_buffer, NULL)))
00614         {
00615                 throw RendererException("DirectX9Renderer::preD3DReset - Failed to create the VertexBuffer for use by the DirectX9Renderer object.");
00616         }
00617 
00618         // perform post-reset operations on all textures
00619         std::list<DirectX9Texture*>::iterator ctex = d_texturelist.begin();
00620         std::list<DirectX9Texture*>::iterator endtex = d_texturelist.end();
00621 
00622         for (; ctex != endtex; ++ctex)
00623         {
00624                 (*ctex)->postD3DReset();
00625         }
00626 
00627         // update display size
00628         setDisplaySize(getViewportSize());
00629 
00630         // Now we've come back, we MUST ensure a full redraw is done since the
00631         // textures in the stored quads will have been invalidated.
00632         System::getSingleton().signalRedraw();
00633 }
00634 
00635 /*************************************************************************
00636         return size of device view port (if possible)   
00637 *************************************************************************/
00638 Size DirectX9Renderer::getViewportSize(void)
00639 {
00640         // initialise renderer size
00641         D3DVIEWPORT9    vp;
00642 
00643         if (FAILED(d_device->GetViewport(&vp)))
00644         {
00645                 throw std::exception("Unable to access required view port information from Direct3DDevice9.");
00646         }
00647         else
00648         {
00649                 return Size((float)vp.Width, (float)vp.Height);
00650         }
00651 
00652 }
00653 
00654 
00655 /*************************************************************************
00656         Set the size of the display in pixels.  
00657 *************************************************************************/
00658 void DirectX9Renderer::setDisplaySize(const Size& sz)
00659 {
00660         if (d_display_area.getSize() != sz)
00661         {
00662                 d_display_area.setSize(sz);
00663 
00664                 EventArgs args;
00665                 fireEvent(EventDisplaySizeChanged, args, EventNamespace);
00666         }
00667 
00668 }
00669 
00670 
00671 } // End of  CEGUI namespace section
00672 

Generated on Wed Feb 16 12:41:08 2005 for Crazy Eddies GUI System by  doxygen 1.3.9.1