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

tpage.cpp File Reference

#include <Windows.h>
#include <Assert.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 (LPDIRECTDRAW7 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 (LPDIRECTDRAW7 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, LPDIRECTDRAW7 lpDD, const DDSURFACEDESC2 *SurfDesc)
void TPage_DestroySurfaces (TPage *Page)
TPage_Block * TPage_BlockCreate (LPDIRECTDRAWSURFACE7 Surface, LPDIRECTDRAWSURFACE7 Texture, const RECT *Rect)
geBoolean TPage_BlockCreateRef (TPage_Block *Block)
void TPage_BlockDestroy (TPage_Block **Block)
LPDIRECTDRAWSURFACE7 TPage_BlockGetTexture (TPage_Block *Block)
LPDIRECTDRAWSURFACE7 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 D3D7xDrv/tpage.cpp.

Referenced by TPage_Create().

#define TPAGE_GRID_Y   16
 

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

Referenced by TPage_Create().

#define TPAGE_HEIGHT   16
 

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

Referenced by TPage_Create(), and TPage_CreateSurfaces().

#define TPAGE_WIDTH   16
 

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

Referenced by TPage_Create(), and TPage_CreateSurfaces().

Typedef Documentation

typedef struct TPage TPage
 

Referenced by TPage_Create(), TPage_Destroy(), TPage_DetachBlock(), TPage_HasBlock(), TPage_MgrAttachTPage(), TPage_MgrCreate(), TPage_MgrDestroy(), TPage_MgrDetachTPage(), TPage_MgrFindOptimalBlock(), and TPage_MgrHasTPage().

typedef struct TPage_Block TPage_Block
 

Referenced by TPage_BlockCreate(), TPage_BlockDestroy(), TPage_Create(), TPage_Destroy(), TPage_HasBlock(), and TPage_MgrFindOptimalBlock().

typedef struct TPage_Mgr TPage_Mgr
 

Function Documentation

geBoolean TPage_AttachBlock (  TPage *  Page,
TPage_Block *  Block
) 
 

Definition at line 465 of file D3D7xDrv/tpage.cpp. 

00466 {
00467         assert(TPage_HasBlock(Page, Block) == GE_FALSE);
00468         assert(Block->Prev == NULL);
00469         assert(Block->Next == NULL);
00470 
00471         // Insert the block into the list of blocks for this Page
00472         if (Page->Blocks)
00473                 Page->Blocks->Prev = Block;
00474 
00475         Block->Prev = NULL;
00476         Block->Next = Page->Blocks;
00477 
00478         Page->Blocks = Block;
00479 
00480         return GE_TRUE;
00481 }

TPage_Block* TPage_BlockCreate (  LPDIRECTDRAWSURFACE7  Surface,
LPDIRECTDRAWSURFACE7  Texture,
const RECT *  Rect
) 
 

Definition at line 594 of file D3D7xDrv/tpage.cpp. 

00596 {
00597         TPage_Block     *Block;
00598 
00599         Block = (TPage_Block*)malloc(sizeof(TPage_Block));
00600 
00601         if (!Block)
00602                 return NULL;
00603 
00604         memset(Block, 0, sizeof(TPage_Block));
00605 
00606         Surface->AddRef();              // Ref the surface
00607 
00608 /*   02/25/2001 Wendell Buckner
00609 /*    This texture pointer is no longer valid under directx 7.  Set it to TRUE so there is
00610 /*    something there when  the code does assert checks.        
00611         Texture->AddRef();              // Ditto...*/
00612 
00613         // Save off the surface, texture, and rect into the surface
00614         Block->Surface = Surface;
00615         Block->Texture = Texture;
00616         Block->Rect = *Rect;
00617 
00618         TPage_BlockCreateRef(Block);            // Create very first ref
00619 
00620         return Block;
00621 }

geBoolean TPage_BlockCreateRef (  TPage_Block *  Block  ) 
 

Definition at line 626 of file D3D7xDrv/tpage.cpp. 

00627 {
00628         assert(Block);
00629 
00630         Block->RefCount++;
00631 
00632         return GE_TRUE;
00633 }

void TPage_BlockDestroy (  TPage_Block **  Block  ) 
 

Definition at line 638 of file D3D7xDrv/tpage.cpp. 

00639 {
00640         TPage_Block     *Block2;
00641 
00642         assert(Block);
00643         
00644         Block2 = *Block;
00645 
00646         assert(Block2);
00647         assert(Block2->RefCount > 0);
00648 
00649         Block2->RefCount--;
00650 
00651         if (Block2->RefCount > 0)
00652                 return;
00653 
00654         // Destroy references to the surface and texture
00655         if (Block2->Surface)
00656                 Block2->Surface->Release();
00657 
00658 /*   02/25/2001 Wendell Buckner
00659 /*    This texture pointer is no longer valid under directx 7.  Set it to TRUE so there is
00660 /*    something there when  the code does assert checks.        
00661         if (Block2->Texture)
00662                 Block2->Texture->Release();*/
00663 
00664         
00665         // Free the block
00666         free(Block2);
00667 
00668         *Block = NULL;
00669 }

const RECT* TPage_BlockGetRect (  TPage_Block *  Block  ) 
 

Definition at line 704 of file D3D7xDrv/tpage.cpp. 

00705 {
00706         assert(Block);
00707 
00708         return &Block->Rect;
00709 }

LPDIRECTDRAWSURFACE7 TPage_BlockGetSurface (  TPage_Block *  Block  ) 
 

Definition at line 693 of file D3D7xDrv/tpage.cpp. 

00695 {
00696         assert(Block);
00697 
00698         return Block->Surface;
00699 }

LPDIRECTDRAWSURFACE7 TPage_BlockGetTexture (  TPage_Block *  Block  ) 
 

Definition at line 678 of file D3D7xDrv/tpage.cpp. 

00680 {
00681         assert(Block);
00682 
00683         return Block->Texture;
00684 }

void* TPage_BlockGetUserData (  TPage_Block *  Block  ) 
 

Definition at line 734 of file D3D7xDrv/tpage.cpp. 

00735 {
00736         assert(Block);
00737 
00738         return Block->UserData;
00739 }

void TPage_BlockSetLRU (  TPage_Block *  Block,
uint32  LRU
) 
 

Definition at line 714 of file D3D7xDrv/tpage.cpp. 

00715 {
00716         assert(Block);
00717 
00718         Block->LRU = LRU;
00719 }

void TPage_BlockSetUserData (  TPage_Block *  Block,
void *  UserData
) 
 

Definition at line 724 of file D3D7xDrv/tpage.cpp. 

00725 {
00726         assert(Block);
00727 
00728         Block->UserData = UserData;
00729 }

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

Definition at line 335 of file D3D7xDrv/tpage.cpp. 

00337 {
00338         TPage   *Page;
00339         int32   w, h;
00340 
00341         Page = (TPage*)malloc(sizeof(TPage));
00342 
00343         if (!Page)
00344                 return NULL;
00345 
00346         memset(Page, 0, sizeof(TPage));
00347 
00348         Page->SurfaceDesc = *SurfDesc;
00349 
00350         TPage_CreateRef(Page);          // Create the very first ref
00351 
00352         if (!TPage_CreateSurfaces(Page, lpDD, SurfDesc))
00353         {
00354                 free(Page);
00355                 return NULL;
00356         }
00357 
00358         // Create the blocks
00359         for (h=0; h<TPAGE_HEIGHT/16; h++)
00360         {
00361                 for (w=0; w<TPAGE_WIDTH/16; w++)
00362                 {
00363                         TPage_Block             *Block;
00364                         RECT                    Rect;
00365 
00366                         Rect.left = w*TPAGE_GRID_X;
00367                         Rect.right = Rect.left+(TPAGE_GRID_X-1);
00368                         Rect.top = h*TPAGE_GRID_Y;
00369                         Rect.bottom = Rect.top+(TPAGE_GRID_Y-1);
00370 
00371                         Block = TPage_BlockCreate(Page->Surface, Page->Texture, &Rect);
00372 
00373                         if (!Block)
00374                                 goto ExitWithError;
00375 
00376                         if (!TPage_AttachBlock(Page, Block))
00377                                 goto ExitWithError;
00378                 }
00379         }
00380 
00381         return Page;
00382 
00383         ExitWithError:
00384         {
00385                 if (Page)
00386                         TPage_Destroy(&Page);
00387 
00388                 return NULL;
00389         }
00390 }

void TPage_CreateRef (  TPage *  Page  ) 
 

Definition at line 395 of file D3D7xDrv/tpage.cpp. 

00396 {
00397         assert(Page->RefCount >= 0);            // Refs can == 0, because thats what they are when TPages are first created
00398 
00399         Page->RefCount++;
00400 }

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

Definition at line 516 of file D3D7xDrv/tpage.cpp. 

00517 {
00518         HRESULT                                 Hr;
00519         DDSURFACEDESC2                  ddsd;
00520 
00521         assert(Page);
00522 
00523         memcpy(&ddsd, SurfDesc, sizeof(DDSURFACEDESC2));
00524 
00525         ddsd.dwSize = sizeof(DDSURFACEDESC2);
00526         ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
00527 
00528         ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
00529         ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_HINTDYNAMIC;
00530 
00531         ddsd.ddsCaps.dwCaps3 = 0;
00532         ddsd.ddsCaps.dwCaps4 = 0;
00533 
00534         ddsd.dwWidth = TPAGE_WIDTH;
00535         ddsd.dwHeight = TPAGE_HEIGHT;
00536 
00537         Hr = lpDD->CreateSurface(&ddsd, &Page->Surface, NULL);
00538 
00539         if (Hr != DD_OK) 
00540                 return GE_FALSE;
00541 
00542 /*   02/25/2001 Wendell Buckner
00543 /*    This texture pointer is no longer valid under directx 7.  Set it to TRUE so there is
00544 /*    something there when  the code does assert checks.        
00545         Hr = Page->Surface->QueryInterface(IID_IDirect3DTexture2, (void**)&Page->Texture);  
00546 
00547         if(Hr != DD_OK) 
00548         { 
00549                 Page->Surface->Release();
00550                 Page->Surface = NULL;
00551                 Page->Texture = NULL;
00552                 return GE_FALSE;
00553         }*/
00554         Page->Texture = Page->Surface;
00555         
00556         return GE_TRUE;         // All good dude
00557 }

void TPage_Destroy (  TPage **  Page1  ) 
 

Definition at line 405 of file D3D7xDrv/tpage.cpp. 

00406 {
00407         TPage           *Page;
00408         TPage_Block     *Block, *Next;
00409 
00410         assert(Page1);
00411         Page = *Page1;
00412 
00413         assert(Page);
00414         assert(Page->RefCount > 0);
00415 
00416         Page->RefCount--;
00417 
00418         if (Page->RefCount > 0)
00419                 return;
00420 
00421         // Destroy any dd surfaces for this page
00422         TPage_DestroySurfaces(Page);
00423 
00424         // Destroy all the blocks this page has
00425         for (Block = Page->Blocks; Block; Block = Next)
00426         {
00427                 Next = Block->Next;
00428 
00429                 TPage_DetachBlock(Page, Block);
00430                 TPage_BlockDestroy(&Block);
00431         }
00432 
00433         assert(Page->Blocks == NULL);
00434 
00435         free(*Page1);
00436 
00437         *Page1 = NULL;
00438 }

void TPage_DestroySurfaces (  TPage *  Page  ) 
 

Definition at line 563 of file D3D7xDrv/tpage.cpp. 

00564 {
00565         assert(Page);
00566 
00567         if (Page->Texture)
00568         {
00569 /*   02/25/2001 Wendell Buckner
00570 /*    This texture pointer is no longer valid under directx 7.  Set it to TRUE so there is
00571 /*    something there when  the code does assert checks.        
00572                 Page->Texture->Release();*/
00573                 Page->Texture = NULL;
00574         }
00575 
00576         if (Page->Surface)
00577         {
00578                 Page->Surface->Release();
00579                 Page->Surface = NULL;
00580         }
00581 }

void TPage_DetachBlock (  TPage *  TPage,
TPage_Block *  Block
) 
 

Definition at line 486 of file D3D7xDrv/tpage.cpp. 

00487 {
00488         assert(TPage);
00489         assert(Block);
00490         assert(TPage_HasBlock(TPage, Block) == GE_TRUE);
00491 
00492         if (Block->Next)
00493                 Block->Next->Prev = Block->Prev;
00494 
00495         if (Block->Prev)
00496                 Block->Prev->Next = Block->Prev;
00497         else
00498         {
00499                 // If we get here, this better be the first Block in the list!
00500                 assert(TPage->Blocks == Block);
00501                 TPage->Blocks = Block->Next;
00502         }
00503 
00504         // Reset the Block link
00505         Block->Next = NULL;
00506         Block->Prev = NULL;
00507 }

geBoolean TPage_HasBlock (  TPage *  TPage,
TPage_Block *  Block
) 
 

Definition at line 443 of file D3D7xDrv/tpage.cpp. 

00444 {
00445         TPage_Block             *Block2;
00446 
00447         assert(TPage);
00448         assert(Block);
00449 
00450         for (Block2 = TPage->Blocks; Block2; Block2 = Block2->Next)
00451         {
00452                 if (Block2 == Block)
00453                 {
00454                         return GE_TRUE;
00455                 }
00456         }
00457 
00458         return GE_FALSE;
00459 }

geBoolean TPage_MgrAttachTPage (  TPage_Mgr *  Mgr,
TPage *  TPage
) 
 

Definition at line 212 of file D3D7xDrv/tpage.cpp. 

00213 {
00214         assert(TPage_MgrHasTPage(Mgr, TPage) == GE_FALSE);
00215         assert(TPage->Prev == NULL);
00216         assert(TPage->Next == NULL);
00217 
00218         if (Mgr->TPages)
00219                 Mgr->TPages->Prev = TPage;
00220 
00221         TPage->Prev = NULL;
00222         TPage->Next = Mgr->TPages;
00223         Mgr->TPages = TPage;
00224 
00225         return GE_TRUE;
00226 }

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

Definition at line 110 of file D3D7xDrv/tpage.cpp. 

00112 {
00113         TPage_Mgr       *TPageMgr;
00114         int32           i;
00115 
00116         TPageMgr = (TPage_Mgr*)malloc(sizeof(TPage_Mgr));
00117 
00118         if (!TPageMgr)
00119                 return NULL;
00120 
00121         memset(TPageMgr, 0, sizeof(TPage_Mgr));
00122 
00123         // Remeber the DD object
00124         TPageMgr->lpDD = lpDD;
00125         // Ref the dd object
00126         lpDD->AddRef();                 
00127 
00128         TPageMgr->NumPages = NumPages;
00129 
00130         // Create the pages
00131         for (i=0; i<NumPages; i++)
00132         {
00133                 TPage   *Page;
00134 
00135                 Page = TPage_Create(lpDD, SurfaceDesc);
00136 
00137                 if (!Page)
00138                         goto ExitWithError;
00139 
00140                 if (!TPage_MgrAttachTPage(TPageMgr, Page))
00141                         goto ExitWithError;
00142         }
00143 
00144         return TPageMgr;
00145 
00146         ExitWithError:
00147         {
00148                 if (TPageMgr)
00149                         TPage_MgrDestroy(&TPageMgr);
00150                 return NULL;
00151         }
00152 }

void TPage_MgrDestroy (  TPage_Mgr **  TPageMgr  ) 
 

Definition at line 157 of file D3D7xDrv/tpage.cpp. 

00158 {
00159         TPage_Mgr       *Mgr;
00160         TPage           *Page, *Next;
00161 
00162         assert(TPageMgr);
00163 
00164         Mgr = *TPageMgr;
00165 
00166         assert(Mgr);
00167         
00168         // Free the pages
00169         for (Page = Mgr->TPages; Page; Page = Next)
00170         {
00171                 Next = Page->Next;
00172 
00173                 TPage_MgrDetachTPage(Mgr, Page);
00174                 TPage_Destroy(&Page);
00175         }
00176 
00177         assert(Mgr->TPages == NULL);
00178 
00179         // Release our ref on the DD object
00180         Mgr->lpDD->Release();                   
00181 
00182         free(*TPageMgr);
00183 
00184         *TPageMgr = NULL;
00185 }

void TPage_MgrDetachTPage (  TPage_Mgr *  Mgr,
TPage *  TPage
) 
 

Definition at line 231 of file D3D7xDrv/tpage.cpp. 

00232 {
00233         assert(Mgr);
00234         assert(TPage);
00235         assert(TPage_MgrHasTPage(Mgr, TPage) == GE_TRUE);
00236 
00237         if (TPage->Next)
00238                 TPage->Next->Prev = TPage->Prev;
00239 
00240         if (TPage->Prev)
00241                 TPage->Prev->Next = TPage->Prev;
00242         else
00243         {
00244                 // If we get here, this better be the first TPage in the list!
00245                 assert(Mgr->TPages == TPage);
00246                 Mgr->TPages = TPage->Next;
00247         }
00248 
00249         TPage->Next = NULL;
00250         TPage->Prev = NULL;
00251 }

TPage_Block* TPage_MgrFindOptimalBlock (  TPage_Mgr *  Mgr,
uint32  LRU
) 
 

Definition at line 256 of file D3D7xDrv/tpage.cpp. 

00257 {
00258 #if 0
00259         TPage           *Page, *BestPage;
00260         TPage_Block     *Block, *BestBlock;
00261         uint32          BestLRU;
00262 
00263         // We really should make a TPage_GetOptimalBlock...
00264 
00265         // First, find the page that has the highest LRU
00266         BestLRU = 0;
00267         BestPage = Mgr->TPages;
00268 
00269         for (Page = Mgr->TPages; Page; Page = Page->Next)
00270         {
00271                 if (Page->LRU > BestLRU && Page->NumFull)
00272                 {
00273                         BestPage = Page;
00274                         BestLRU = Page->LRU;
00275                 }
00276         }
00277 
00278         // Now, find the block with the lowest LRU in this page
00279         BestBlock = BestPage->Blocks;
00280         BestLRU = 0xffffffff;
00281 
00282         for (Block = BestPage->Blocks; Block; Block = Block->Next)
00283         {
00284                 if (Block->LRU < BestLRU)
00285                 {
00286                         BestBlock = Block;
00287                         BestLRU = Block->LRU;
00288                 }
00289         }
00290         /*
00291         if (BestBlock->LRU == LRU)
00292                 BestPage->NumFull++;
00293         else
00294         */
00295                 BestBlock->LRU = LRU;
00296         BestPage->LRU = LRU;
00297 #else
00298         TPage           *Page;
00299         TPage_Block     *Block, *BestBlock;
00300         uint32          BestLRU;
00301 
00302         // We really should make a TPage_GetOptimalBlock...
00303         BestBlock = NULL;
00304         BestLRU = 0xffffffff;
00305 
00306         for (Page = Mgr->TPages; Page; Page = Page->Next)
00307         {
00308                 for (Block = Page->Blocks; Block; Block = Block->Next)
00309                 {
00310                         if (Block->LRU < BestLRU)
00311                         {
00312                                 BestBlock = Block;
00313                                 BestLRU = Block->LRU;
00314                         }
00315                 }
00316         }
00317 
00318         BestBlock->LRU = LRU;
00319 #endif
00320 
00321         return BestBlock;
00322 }

geBoolean TPage_MgrHasTPage (  TPage_Mgr *  Mgr,
TPage *  Page
) 
 

Definition at line 190 of file D3D7xDrv/tpage.cpp. 

00191 {
00192         TPage   *Page2;
00193 
00194         assert(Mgr);
00195         assert(Page);
00196 
00197         for (Page2 = Mgr->TPages; Page2; Page2 = Page2->Next)
00198         {
00199                 if (Page2 == Page)
00200                 {
00201                         return GE_TRUE;
00202                 }
00203         }
00204         
00205         return GE_FALSE;
00206 }

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