Main Page | Alphabetical List | Compound List | File List | Compound Members | File Members

tpage.cpp File Reference

#include <Windows.h>
#include <Stdio.h>
#include "BaseType.h"
#include "TPage.h"

Go to the source code of this file.

Compounds

struct  TPage
struct  TPage_Block
struct  TPage_Mgr

Defines

#define TPAGE_WIDTH   16
#define TPAGE_HEIGHT   16
#define TPAGE_GRID_X   16
#define TPAGE_GRID_Y   16

Typedefs

typedef TPage_Block TPage_Block
typedef TPage TPage
typedef TPage_Mgr TPage_Mgr

Functions

TPage_Mgr * TPage_MgrCreate (LPDIRECTDRAW4 lpDD, const DDSURFACEDESC2 *SurfaceDesc, int32 NumPages)
void TPage_MgrDestroy (TPage_Mgr **TPageMgr)
geBoolean TPage_MgrHasTPage (TPage_Mgr *Mgr, TPage *Page)
geBoolean TPage_MgrAttachTPage (TPage_Mgr *Mgr, TPage *TPage)
void TPage_MgrDetachTPage (TPage_Mgr *Mgr, TPage *TPage)
TPage_Block * TPage_MgrFindOptimalBlock (TPage_Mgr *Mgr, uint32 LRU)
TPage * TPage_Create (LPDIRECTDRAW4 lpDD, const DDSURFACEDESC2 *SurfDesc)
void TPage_CreateRef (TPage *Page)
void TPage_Destroy (TPage **Page1)
geBoolean TPage_HasBlock (TPage *TPage, TPage_Block *Block)
geBoolean TPage_AttachBlock (TPage *Page, TPage_Block *Block)
void TPage_DetachBlock (TPage *TPage, TPage_Block *Block)
geBoolean TPage_CreateSurfaces (TPage *Page, LPDIRECTDRAW4 lpDD, const DDSURFACEDESC2 *SurfDesc)
void TPage_DestroySurfaces (TPage *Page)
TPage_Block * TPage_BlockCreate (LPDIRECTDRAWSURFACE4 Surface, LPDIRECT3DTEXTURE2 Texture, const RECT *Rect)
geBoolean TPage_BlockCreateRef (TPage_Block *Block)
void TPage_BlockDestroy (TPage_Block **Block)
LPDIRECT3DTEXTURE2 TPage_BlockGetTexture (TPage_Block *Block)
LPDIRECTDRAWSURFACE4 TPage_BlockGetSurface (TPage_Block *Block)
const RECT * TPage_BlockGetRect (TPage_Block *Block)
void TPage_BlockSetLRU (TPage_Block *Block, uint32 LRU)
void TPage_BlockSetUserData (TPage_Block *Block, void *UserData)
void * TPage_BlockGetUserData (TPage_Block *Block)

Define Documentation

#define TPAGE_GRID_X   16
 

Definition at line 38 of file D3D8Drv/tpage.cpp.

#define TPAGE_GRID_Y   16
 

Definition at line 39 of file D3D8Drv/tpage.cpp.

#define TPAGE_HEIGHT   16
 

Definition at line 36 of file D3D8Drv/tpage.cpp.

#define TPAGE_WIDTH   16
 

Definition at line 35 of file D3D8Drv/tpage.cpp.

Typedef Documentation

typedef struct TPage TPage
 

typedef struct TPage_Block TPage_Block
 

typedef struct TPage_Mgr TPage_Mgr
 

Function Documentation

geBoolean TPage_AttachBlock (  TPage *  Page,
TPage_Block *  Block
) 
 

Definition at line 372 of file D3D8Drv/tpage.cpp.

References TPage::Blocks, GE_TRUE, geBoolean, TPage_Block::Next, NULL, and TPage_Block::Prev. 

00373 {
00374         // Insert the block into the list of blocks for this Page
00375         if (Page->Blocks)
00376                 Page->Blocks->Prev = Block;
00377 
00378         Block->Prev = NULL;
00379         Block->Next = Page->Blocks;
00380 
00381         Page->Blocks = Block;
00382 
00383         return GE_TRUE;
00384 }

TPage_Block* TPage_BlockCreate (  LPDIRECTDRAWSURFACE4  Surface,
LPDIRECT3DTEXTURE2  Texture,
const RECT *  Rect
) 
 

Definition at line 470 of file D3D8Drv/tpage.cpp. 

00471 {
00472         TPage_Block     *Block;
00473 
00474         Block = (TPage_Block*)malloc(sizeof(TPage_Block));
00475 
00476         if (!Block)
00477                 return NULL;
00478 
00479         memset(Block, 0, sizeof(TPage_Block));
00480 
00481         Surface->AddRef();              // Ref the surface
00482         Texture->AddRef();              // Ditto...
00483 
00484         // Save off the surface, texture, and rect into the surface
00485         Block->Surface = Surface;
00486         Block->Texture = Texture;
00487         Block->Rect = *Rect;
00488 
00489         TPage_BlockCreateRef(Block);            // Create very first ref
00490 
00491         return Block;
00492 }

geBoolean TPage_BlockCreateRef (  TPage_Block *  Block  ) 
 

Definition at line 497 of file D3D8Drv/tpage.cpp.

References GE_TRUE, geBoolean, and TPage_Block::RefCount. 

00498 {
00499         Block->RefCount++;
00500 
00501         return GE_TRUE;
00502 }

void TPage_BlockDestroy (  TPage_Block **  Block  ) 
 

Definition at line 507 of file D3D8Drv/tpage.cpp.

References NULL, TPage_Block::RefCount, TPage_Block::Surface, TPage_Block::Texture, and TPage_Block. 

00508 {
00509         TPage_Block     *Block2;
00510 
00511         Block2 = *Block;
00512 
00513         Block2->RefCount--;
00514 
00515         if (Block2->RefCount > 0)
00516                 return;
00517 
00518         // Destroy references to the surface and texture
00519         if (Block2->Surface)
00520                 Block2->Surface->Release();
00521 
00522         if (Block2->Texture)
00523                 Block2->Texture->Release();
00524         
00525         // Free the block
00526         free(Block2);
00527 
00528         *Block = NULL;
00529 }

const RECT* TPage_BlockGetRect (  TPage_Block *  Block  ) 
 

Definition at line 550 of file D3D8Drv/tpage.cpp.

References TPage_Block::Rect. 

00551 {
00552         return &Block->Rect;
00553 }

LPDIRECTDRAWSURFACE4 TPage_BlockGetSurface (  TPage_Block *  Block  ) 
 

Definition at line 542 of file D3D8Drv/tpage.cpp.

References TPage_Block::Surface. 

00543 {
00544         return Block->Surface;
00545 }

LPDIRECT3DTEXTURE2 TPage_BlockGetTexture (  TPage_Block *  Block  ) 
 

Definition at line 534 of file D3D8Drv/tpage.cpp.

References TPage_Block::Texture. 

00535 {
00536         return Block->Texture;
00537 }

void* TPage_BlockGetUserData (  TPage_Block *  Block  ) 
 

Definition at line 574 of file D3D8Drv/tpage.cpp.

References TPage_Block::UserData. 

00575 {
00576         return Block->UserData;
00577 }

void TPage_BlockSetLRU (  TPage_Block *  Block,
uint32  LRU
) 
 

Definition at line 558 of file D3D8Drv/tpage.cpp.

References TPage_Block::LRU. 

00559 {
00560         Block->LRU = LRU;
00561 }

void TPage_BlockSetUserData (  TPage_Block *  Block,
void *  UserData
) 
 

Definition at line 566 of file D3D8Drv/tpage.cpp.

References TPage_Block::UserData. 

00567 {
00568         Block->UserData = UserData;
00569 }

TPage* TPage_Create (  LPDIRECTDRAW4  lpDD,
const DDSURFACEDESC2 *  SurfDesc
) 
 

Definition at line 254 of file D3D8Drv/tpage.cpp. 

00255 {
00256         TPage   *Page;
00257         int32   w, h;
00258 
00259         Page = (TPage*)malloc(sizeof(TPage));
00260 
00261         if (!Page)
00262                 return NULL;
00263 
00264         memset(Page, 0, sizeof(TPage));
00265 
00266         Page->SurfaceDesc = *SurfDesc;
00267 
00268         TPage_CreateRef(Page);          // Create the very first ref
00269 
00270         if (!TPage_CreateSurfaces(Page, lpDD, SurfDesc))
00271         {
00272                 free(Page);
00273                 return NULL;
00274         }
00275 
00276         // Create the blocks
00277         for (h=0; h<TPAGE_HEIGHT/16; h++)
00278         {
00279                 for (w=0; w<TPAGE_WIDTH/16; w++)
00280                 {
00281                         TPage_Block             *Block;
00282                         RECT                    Rect;
00283 
00284                         Rect.left = w*TPAGE_GRID_X;
00285                         Rect.right = Rect.left+(TPAGE_GRID_X-1);
00286                         Rect.top = h*TPAGE_GRID_Y;
00287                         Rect.bottom = Rect.top+(TPAGE_GRID_Y-1);
00288 
00289                         Block = TPage_BlockCreate(Page->Surface, Page->Texture, &Rect);
00290 
00291                         if (!Block)
00292                                 goto ExitWithError;
00293 
00294                         if (!TPage_AttachBlock(Page, Block))
00295                                 goto ExitWithError;
00296                 }
00297         }
00298 
00299         return Page;
00300 
00301         ExitWithError:
00302         {
00303                 if (Page)
00304                         TPage_Destroy(&Page);
00305 
00306                 return NULL;
00307         }
00308 }

void TPage_CreateRef (  TPage *  Page  ) 
 

Definition at line 313 of file D3D8Drv/tpage.cpp.

References TPage::RefCount. 

00314 {
00315         Page->RefCount++;
00316 }

geBoolean TPage_CreateSurfaces (  TPage *  Page,
LPDIRECTDRAW4  lpDD,
const DDSURFACEDESC2 *  SurfDesc
) 
 

Definition at line 410 of file D3D8Drv/tpage.cpp. 

00411 {
00412         HRESULT                                 Hr;
00413         DDSURFACEDESC2                  ddsd;
00414 
00415         memcpy(&ddsd, SurfDesc, sizeof(DDSURFACEDESC2));
00416 
00417         ddsd.dwSize = sizeof(DDSURFACEDESC2);
00418         ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
00419         ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
00420         ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_HINTDYNAMIC;
00421         ddsd.ddsCaps.dwCaps3 = 0;
00422         ddsd.ddsCaps.dwCaps4 = 0;
00423         ddsd.dwWidth = TPAGE_WIDTH;
00424         ddsd.dwHeight = TPAGE_HEIGHT;
00425 
00426         Hr = lpDD->CreateSurface(&ddsd, &Page->Surface, NULL);
00427 
00428         if (Hr != DD_OK) 
00429                 return GE_FALSE;
00430 
00431         Hr = Page->Surface->QueryInterface(IID_IDirect3DTexture2, (void**)&Page->Texture);  
00432 
00433         if(Hr != DD_OK) 
00434         { 
00435                 Page->Surface->Release();
00436                 Page->Surface = NULL;
00437                 Page->Texture = NULL;
00438                 return GE_FALSE;
00439         }
00440         
00441         return GE_TRUE;         // All good dude
00442 }

void TPage_Destroy (  TPage **  Page1  ) 
 

Definition at line 321 of file D3D8Drv/tpage.cpp.

References TPage::Blocks, TPage_Block::Next, NULL, TPage::RefCount, TPage, TPage_Block, TPage_BlockDestroy(), TPage_DestroySurfaces(), and TPage_DetachBlock(). 

00322 {
00323         TPage           *Page;
00324         TPage_Block     *Block, *Next;
00325 
00326         Page = *Page1;
00327 
00328         Page->RefCount--;
00329 
00330         if (Page->RefCount > 0)
00331                 return;
00332 
00333         // Destroy any dd surfaces for this page
00334         TPage_DestroySurfaces(Page);
00335 
00336         // Destroy all the blocks this page has
00337         for (Block = Page->Blocks; Block; Block = Next)
00338         {
00339                 Next = Block->Next;
00340 
00341                 TPage_DetachBlock(Page, Block);
00342                 TPage_BlockDestroy(&Block);
00343         }
00344 
00345         free(*Page1);
00346 
00347         *Page1 = NULL;
00348 }

void TPage_DestroySurfaces (  TPage *  Page  ) 
 

Definition at line 448 of file D3D8Drv/tpage.cpp.

References NULL, TPage::Surface, and TPage::Texture. 

00449 {
00450         if (Page->Texture)
00451         {
00452                 Page->Texture->Release();
00453                 Page->Texture = NULL;
00454         }
00455 
00456         if (Page->Surface)
00457         {
00458                 Page->Surface->Release();
00459                 Page->Surface = NULL;
00460         }
00461 }

void TPage_DetachBlock (  TPage *  TPage,
TPage_Block *  Block
) 
 

Definition at line 389 of file D3D8Drv/tpage.cpp.

References TPage::Blocks, TPage_Block::Next, NULL, TPage_Block::Prev, and TPage. 

00390 {
00391         if (Block->Next)
00392                 Block->Next->Prev = Block->Prev;
00393 
00394         if (Block->Prev)
00395                 Block->Prev->Next = Block->Prev;
00396         else
00397         {
00398                 // If we get here, this better be the first Block in the list!
00399                 TPage->Blocks = Block->Next;
00400         }
00401 
00402         // Reset the Block link
00403         Block->Next = NULL;
00404         Block->Prev = NULL;
00405 }

geBoolean TPage_HasBlock (  TPage *  TPage,
TPage_Block *  Block
) 
 

Definition at line 353 of file D3D8Drv/tpage.cpp.

References TPage::Blocks, GE_FALSE, GE_TRUE, geBoolean, TPage_Block::Next, TPage, and TPage_Block. 

00354 {
00355         TPage_Block             *Block2;
00356 
00357         for (Block2 = TPage->Blocks; Block2; Block2 = Block2->Next)
00358         {
00359                 if (Block2 == Block)
00360                 {
00361                         return GE_TRUE;
00362                 }
00363         }
00364 
00365         return GE_FALSE;
00366 }

geBoolean TPage_MgrAttachTPage (  TPage_Mgr *  Mgr,
TPage *  TPage
) 
 

Definition at line 185 of file D3D8Drv/tpage.cpp.

References GE_TRUE, geBoolean, TPage::Next, NULL, TPage::Prev, TPage, and TPage_Mgr::TPages. 

00186 {
00187         if (Mgr->TPages)
00188                 Mgr->TPages->Prev = TPage;
00189 
00190         TPage->Prev = NULL;
00191         TPage->Next = Mgr->TPages;
00192         Mgr->TPages = TPage;
00193 
00194         return GE_TRUE;
00195 }

TPage_Mgr* TPage_MgrCreate (  LPDIRECTDRAW4  lpDD,
const DDSURFACEDESC2 *  SurfaceDesc,
int32  NumPages
) 
 

Definition at line 93 of file D3D8Drv/tpage.cpp. 

00094 {
00095         TPage_Mgr       *TPageMgr;
00096         int32           i;
00097 
00098         TPageMgr = (TPage_Mgr*)malloc(sizeof(TPage_Mgr));
00099 
00100         if (!TPageMgr)
00101                 return NULL;
00102 
00103         memset(TPageMgr, 0, sizeof(TPage_Mgr));
00104 
00105         // Remeber the DD object
00106         TPageMgr->lpDD = lpDD;
00107         // Ref the dd object
00108         lpDD->AddRef();                 
00109 
00110         TPageMgr->NumPages = NumPages;
00111 
00112         // Create the pages
00113         for (i=0; i<NumPages; i++)
00114         {
00115                 TPage   *Page;
00116 
00117                 Page = TPage_Create(lpDD, SurfaceDesc);
00118 
00119                 if (!Page)
00120                         goto ExitWithError;
00121 
00122                 if (!TPage_MgrAttachTPage(TPageMgr, Page))
00123                         goto ExitWithError;
00124         }
00125 
00126         return TPageMgr;
00127 
00128         ExitWithError:
00129         {
00130                 if (TPageMgr)
00131                         TPage_MgrDestroy(&TPageMgr);
00132                 return NULL;
00133         }
00134 }

void TPage_MgrDestroy (  TPage_Mgr **  TPageMgr  ) 
 

Definition at line 139 of file D3D8Drv/tpage.cpp.

References TPage_Mgr::lpDD, TPage::Next, NULL, TPage, TPage_Destroy(), TPage_MgrDetachTPage(), TPageMgr, and TPage_Mgr::TPages. 

00140 {
00141         TPage_Mgr       *Mgr;
00142         TPage           *Page, *Next;
00143 
00144         Mgr = *TPageMgr;
00145 
00146         // Free the pages
00147         for (Page = Mgr->TPages; Page; Page = Next)
00148         {
00149                 Next = Page->Next;
00150 
00151                 TPage_MgrDetachTPage(Mgr, Page);
00152                 TPage_Destroy(&Page);
00153         }
00154 
00155         // Release our ref on the DD object
00156         Mgr->lpDD->Release();                   
00157 
00158         free(*TPageMgr);
00159 
00160         *TPageMgr = NULL;
00161 }

void TPage_MgrDetachTPage (  TPage_Mgr *  Mgr,
TPage *  TPage
) 
 

Definition at line 200 of file D3D8Drv/tpage.cpp.

References TPage::Next, NULL, TPage::Prev, TPage, and TPage_Mgr::TPages. 

00201 {
00202         if (TPage->Next)
00203                 TPage->Next->Prev = TPage->Prev;
00204 
00205         if (TPage->Prev)
00206                 TPage->Prev->Next = TPage->Prev;
00207         else
00208         {
00209                 // If we get here, this better be the first TPage in the list!
00210                 Mgr->TPages = TPage->Next;
00211         }
00212 
00213         TPage->Next = NULL;
00214         TPage->Prev = NULL;
00215 }

TPage_Block* TPage_MgrFindOptimalBlock (  TPage_Mgr *  Mgr,
uint32  LRU
) 
 

Definition at line 220 of file D3D8Drv/tpage.cpp.

References TPage::Blocks, TPage_Block::LRU, TPage_Block::Next, TPage::Next, NULL, TPage, TPage_Block, TPage_Mgr::TPages, and uint32. 

00221 {
00222         TPage           *Page;
00223         TPage_Block     *Block, *BestBlock;
00224         uint32          BestLRU;
00225 
00226         // We really should make a TPage_GetOptimalBlock...
00227         BestBlock = NULL;
00228         BestLRU = 0xffffffff;
00229 
00230         for (Page = Mgr->TPages; Page; Page = Page->Next)
00231         {
00232                 for (Block = Page->Blocks; Block; Block = Block->Next)
00233                 {
00234                         if (Block->LRU < BestLRU)
00235                         {
00236                                 BestBlock = Block;
00237                                 BestLRU = Block->LRU;
00238                         }
00239                 }
00240         }
00241 
00242         BestBlock->LRU = LRU;
00243 
00244         return BestBlock;
00245 }

geBoolean TPage_MgrHasTPage (  TPage_Mgr *  Mgr,
TPage *  Page
) 
 

Definition at line 166 of file D3D8Drv/tpage.cpp.

References GE_FALSE, GE_TRUE, geBoolean, TPage::Next, TPage, and TPage_Mgr::TPages. 

00167 {
00168         TPage   *Page2;
00169 
00170         for (Page2 = Mgr->TPages; Page2; Page2 = Page2->Next)
00171         {
00172                 if (Page2 == Page)
00173                 {
00174                         return GE_TRUE;
00175                 }
00176         }
00177         
00178         return GE_FALSE;
00179 }

Generated on Tue Sep 30 12:38:15 2003 for GTestAndEngine by doxygen 1.3.2