..: C/C++ & Visual C++ :..

Středem pozornosti v dnešní nové lekci bude třída CTerrain a XCamera. S druhou jmenovanou třídou jsme již pracovali v minulé a předminulé lekci, dnes ji tedy pouze doplníme, abychom mohli ořezávat viditelnou scénu. Naopak třídu CTerrain budeme vytvářet úplně od začátku.

30.1. Frustum

O Frustum jsme si pověděli, že je to komolý jehlan, který vymezuje prostor. Všechny objekty, které jsou uvnitř tohoto prostoru, by se měly vykreslit, protože budou vidět. U ostatních objektů je jistota, že vidět nebudou a tím pádem nás nezajímají. Důležité je tedy zajistit, abychom vykreslovali jen ty objekty, které uvnitř jsou a zbytečně neplýtvali výkon těmi ostatními. Abychom takový test mohli vůbec provést, je třeba mít Frustum spočítané a to je úkol této části.

Opět budeme používat hojně pojmů z analytické geometrie. Základ je struktura CLIPVOLUME, která pomocí obecných rovnic rovin přesně definuje Frustum:

typedef struct _CLIPVOLUME
{
   D3DXPLANE pLeft, pRight;
   D3DXPLANE pTop, pBottom;
   D3DXPLANE pNear, pFar;
} CLIPVOLUME;

Což je obecná rovnice roviny v prostoru. Koeficienty a, b a c tedy určují normálový vektor roviny. Atributy pLeft a pRight určují boky, pTop a pBottom je strop a podlaha a nakonec pNear a pFar jsou přední a zadní stěna.

Úkolem je tedy určit všech šest rovin co nejpřesněji. Vypadá to jako nepřekonatelný problém, ale ve skutečnosti je to trochu analytické geometrie ze střední školy. Následuje nová metoda třídy XCamera, která určí Frustum naší kamery:

Vypadá to možná děsivě, ale nyní si vše podrobně vysvětlíme. Pomohou nám následující obrázky. V horní části je vidět vztah mezi třemi důležitými vektory: vDir, vUpDir a vCross. To se také týká první části v kódu, kde od sebe odečteme LookAtPoint a EyePoint a tím získáme vektor kamery vDir. Dále potřebujeme vektor vCross, který je kolmý k vDir, ale zároveň musí být kolmý k vektoru vUpDir. Použijeme tedy vektorový součin. Potíž je v tom, že vUpDir nemusí mířit přímo nahoru, ale bude nakloněn tak, aby byl kolmý na vDir, který bude v našem případě mířit spíš k terénu. Musíme tedy zpětně využít vektor vCross a spočítat správný svislý vektor (opět pomocí vektorového součinu). Nakonec všechny tyto vektory znormalizujeme, aby měly jednotkovou velikost.

Na dalších obrázcích je vidět Frustum směrem od kamery a shora. FOV je úhel pohledu, který máme definovaný jako PI/4, tedy 45 stupňů. V cyklu inicializujeme osm bodů komolého jehlanu (čísla bodů jsou vyznačena na obrázku: 0-7). Nejprve počítáme přední stěnu, poté zadní, použijeme tedy buď konstantu NEAR_CLIP nebo FAR_CLIP. Poté protáhneme vektor vDir o vzdálenost stěny od kamery, tím se dostaneme do středu dané stěny. Proměnné t1 a t2 představují posun ve vertikálním resp. horizontálním směru. Spočítáme je úplně jednoduše pomocí tangenty úhlu FOV/2 (protilehlá ku přilehlé, protilehlá je zde požadovaná proměnná t1/t2 a přilehlá je vzdálenost od kamery - tedy buď NEAR_CLIP nebo FAR_CLIP. Proč bereme jen polovinu uhlu FOV je vidět s obrázku. U t2 navíc musíme počítat s tím, že Frustum nemá čtvercovou podstavu, ale že hrany jsou v poměru 4:3 (konstanta ASPECT). Podle bodu, který zrovna počítáme bude t1/t2 buď kladné nebo záporné a posuneme bod ve směru vDirUp a vCross. Na závěr jen posuneme Frustum do skutečné pozice kamery.

Nyní už bude hračka určit stěny Frustum, neboť máme hned čtyři body, které leží v každé rovině (dokonce by stačily tři). Již jsem zmínil, že koeficienty a, b, c obecné rovnice roviny w, jsou složky normálového vektoru n. Určíme tedy normálové vektory. To provedeme zcela jednoduše. Vybereme si libovolné tři body u každé stěny a spočítáme z nich dva směrové vektory s1 a s2, které leží v rovině w. Poté použijeme vektorový součin k určení vektoru kolmého na oba směrové vektory s1 a s2. To jsme ale získali vektor kolmý na rovinu w, protože s1 a s2 ležely v rovině w a získali jsme tudíž požadovaný vektor n. Zbývá umístit rovinu v prostoru, tedy určit koeficient d. Ten získáme zpětným dosazením libovolného bodu, který leží v rovině, do stávající rovnice. Po úpravách předchozí rovnice dostaneme:

a, b a c již máme. x, y a z určují bod v rovině (můžeme si vybrat libovolný z těch čtyř, které známe). Tyto výpočty provedeme pro každou stěnu Frustum zvlášť.

30.2. Třída CTerrain

V další části se budeme zabývat třídou CTerrain, která zapouzdří to, co jsme dělali v minulé lekci, to znamená tvorbu terénu a navíc k tomu přidáme podporu optimalizace pomocí quad tree. O stromech se dozvíte více v příští lekci Kurzu o datových strukturách. Nám ale budou stačit úplné základy. Navíc teorii jsme již probrali minule a implementace není příliš složitá (pokud znáte rekurzi).

Začneme tedy postupně. Základ bude struktura QTNode, která reprezentuje jeden uzel, popřípadě list stromu.

struct QTNode {
   //
   // Type of node - NODE, LEAF
   NODETYPE ntType;
   //
   // Bounding points
   BoundingPoint arBounds[4];
   //
   // Each node has four branches/children/kids
   // LEAF has not any kids
   QTNode *pBranches[4];
   //
   // leaf's tiles, each LEAF has 25 vertices (2 triangles per tile -> 32 triangles per LEAF)
   // NODE has not any vertices
   IVertexBuffer *pVB;
   BOOL bVis;
};

Struktura obsahuje typ uzlu (buď se jedná o obyčejný uzel nebo o list - tedy uzel bez potomků). Typ NODETYPE je definován takto:

NODE_TYPE tedy představuje obyčejný uzel a LEAF_TYPE list. Dále uchováváme okrajové body uzlu. Tato informace se nám bude hodit při určování, zda-li je uzel uvnitř nebo vně Frustum. Proměnna pBraches je pole čtyř ukazatelů na potomky daného uzlu. Uzly na nejnižší úrovni nazýváme listy, to není nic nového a listy také uchovávají informaci o terénu. V našem případě se jedná přímo o Vertex buffer, což není zcela ideální, ale lépe to vyřešíme v příští lekci. Poslední atribut nám jen říká, zda-li je list vidět či nikoliv. Tuto vlastnost bychom ani nepotřebovali, ale chceme vykreslovat mapu viditelných listů (viz. dále). Na dalším obrázku vidíte význam většiny proměnných:

class CTerrain
{
   DWORD m_dwFlags;
   // Common IB, heightmap and material
   IIndexBuffer *m_pTerrainIB;
   ITexture *m_pTerrainSurface;
   ITexture *m_pHeightMap;
   // Terrain dimensions
   int m_iTerrainTilesX;
   int m_iTerrainTilesY;
   int m_iTerrainVerticesX;
   int m_iTerrainVerticesY;
   // Current terrain method
   TERRAIN_METHOD m_iTerrainMethod;
   I3DFont *m_pDebugFont;

   std::vector <QTNode*> m_arLeaves;
   std::vector <QTNode*> m_arVisQuads;
   //
   // Root of the quad tree
   QTNode *m_pRoot;
   //
   // Vertices...
   VERTEX **m_arTerrain;
   //
   // Common inicialization
   HRESULT InternalInit();
   int CreateNode(QTNode *pNode);
   int FillLeaves();
   int DestroyNode(QTNode *pNode);
   int CircleAlgorithm();
   int ComputeNormals();
   int CreateQuadTree();
   // Fills queue of the visible quads
   HRESULT CullTerrain(QTNode *pNode, CLIPVOLUME& cv);

public:
   HRESULT GenerateTerrain(int x, int y, TERRAIN_METHOD tmMethod = TM_CIRCLE);
   HRESULT GenerateTerrainFromFile(LPCSTR szFile);
   HRESULT DestroyTerrain();
   int GetTitlesX() {return m_iTerrainTilesX;}
   int GetTitlesY() {return m_iTerrainTilesY;}

   void SetFlag(DWORD dwFlag) {m_dwFlags |= dwFlag;}
   void UnsetFlag(DWORD dwFlag) {m_dwFlags &= ~dwFlag;}
   void InvertFlag(DWORD dwFlag) { if(dwFlag & m_dwFlags) { UnsetFlag(dwFlag); } else {                                     SetFlag(dwFlag);}}
   void ResetFlags() {m_dwFlags = 0;}

Červeně jsou označeny soukromé metody. Nyní si ukážeme jednotlivé metody podrobněji.

Jak jsem již zmínil, tato metoda vytvoří terén z heightmapy. Prakticky shrnuje vše, co jsme napsali v minulé lekci. Nejprve vytvoříme společné objekty jako je font nebo textura povrchu, pak načteme texturu heightmapy do paměti, vytvoříme 2D pole terénu a naplníme ho daty podle textury. Nakonec spočteme normály a vytvoříme strom.

HRESULT CTerrain::GenerateTerrain(int x, int y, TERRAIN_METHOD tmMethod /*= TM_CIRCLE*/)
{

Tato metoda je podobná, opět se volá metoda InternalInit() a pak se vytvoří 2D pole vertexů, které se naplní daty. Použije se algoritmus kopečků a spočítají se normály. Na závěr postavíme strom. V předchozích metodách také ukládáme velikost terénu. V prvním případě se bere podle velikost textury heightmapy. Ve druhém je pak dána dvěma parametry.

Protože s přípravou terénu úzce souvisí metoda InternalInit(), podívejme se teď na ní:

Nejedná se o nic složitého, protože metoda má jen za úkol vytvořit pár objektů: font, kterým píšeme informace o terénu na obrazovku, index buffer jednoho listu, který využijeme při vykreslování a textura povrchu terénu - naše známá tráva.

Veledůležitou metodou a vlastně podstatou je CreateNode(). Tato metoda je rekurzivní tzn. že volá sama sebe pro každý uzel stromu. Začínáme od kořene v metodě CreateQuadTree():

Zde tedy připravíme první uzel - kořen - a zavoláme CreateNode(). Na závěr naplníme všechny listy daty pomocí metody Restore(). Všimněte si inicializace okrajových bodů. Jednoduše použijeme krajní body pole m_arTerrain, protože kořen je přes celý terén, uzel s největší rozlohou.

Metoda vypadající na první pohled složitě. Na druhý je to úplně jednoduché. Nejprve potřebujeme spočítat velikost aktuálního uzlu (tj. uzlu, pro který byla metoda volána). Otec tohoto uzlu ovšem pro nás spočítal okrajové body, stačí tedy od sebe odečíst ty správné dva a dostaneme tak šířku uiWidth a "výšku" uiHeight uzlu. Dále testujeme, zda-li jsme již nedosáhli nejnižší "listové" úrovně. Velikost listu definuje konstanta LEAF_I_SIZE. Pokud ano, aktuální uzel je list a provedeme tři operace: uzel si musí pamatovat, že je list, vytvoří se pro něj vertex buffer (zatím se neplní) a vloží se do pole listů - v tomto bodě je metoda ukončena a vracíme se o úroveň výš.
Pokud je ale uzel ještě příliš velký, je třeba ho znovu rozčtvrtit a pro každou čtvrtinu zavolat CreateNode(). Takže vytvoříme čtyři nové uzly a nastavíme jim nové krajní body tak, aby pokryly předcházející uzel. Tohle si určitě nakreslete na kousek papíru!

Listy máme uloženy v poli m_arLeaves a nyní je musíme naplnit daty z hlavního pole celého terénu m_arTerrain:

int CTerrain::FillLeaves()
{
   QTNode *pNode;
   VERTEX *pVertices;
   int v, y, x, i;
   for(i = 0; i < (int)m_arLeaves.size(); i++)
   {
      pNode = (QTNode*)m_arLeaves[i];
      pNode->pVB->GetBuffer()->Lock(0, 0, (BYTE**) &pVertices, 0);

      v = 0;
      for(y = (int)pNode->arBounds[0].y; y <= (int)pNode->arBounds[2].y; y++)
      {
         for(x = (int)pNode->arBounds[0].x; x <= (int)pNode->arBounds[1].x; x++)
         {
            pVertices[v] = m_arTerrain[x][y];
            v++;
         }
      }
      pNode->pVB->GetBuffer()->Unlock();
   }
   return -1;
}

Zbývá metoda pro naplnění a obnovu Vertex a Index bufferu. Při ztrátě zařízení (a i při inicializaci) se automatický volá metoda Restore(), která naplní IB a volá metodu pro naplnění všech listů:

HRESULT CTerrain::Restore()
{
   WORD *pIndices;
   DWORD dwRet = S_FALSE;
   int x, y, i = 0;

   if(m_arTerrain)
   {
      TRACE("Restoring terrain surface...");
      dwRet = m_pTerrainIB->GetBuffer()->Lock(0, 0, (BYTE**)&pIndices, 0);
      for(y = 0; y < LEAF_I_SIZE; y++)
      {
         for(x = 0; x < LEAF_I_SIZE; x++)
         {
            pIndices[i + 0] = x + y * LEAF_V_SIZE;
            pIndices[i + 1] = (x+1) + y * LEAF_V_SIZE;
            pIndices[i + 2] = x + (y+1) * LEAF_V_SIZE;
            i += 3;
            pIndices[i + 0] = (x+1) + y * LEAF_V_SIZE;
            pIndices[i + 1] = (x+1) + (y+1) * LEAF_V_SIZE;
            pIndices[i + 2] = x + (y+1) * LEAF_V_SIZE;
            i += 3;
         }
      }
      dwRet = m_pTerrainIB->GetBuffer()->Unlock();
      dwRet = FillLeaves();
   }
   return dwRet;
}

V Index bufferu jsou odkazy v rámci jednoho listu, protože listy budeme vykreslovat postupně. Princip naleznete v minulé lekci - je to jako kdybychom měli malý povrch o rozměrech jednoho listu.

Nyní si ukážeme jak ořezávat listy, které jsou mimo Frustum. Ořezávání se provádí v metodě CullTerrain(). Jedná se opět o rekurzivní metodu (všimněte si, že pokud pracujeme se stromem, rekurze nám podstatně zjednodušuje život). Výsledek metody je seznam viditelných listů:

// Fills queue of the visible quads
HRESULT CTerrain::CullTerrain(QTNode *pNode, CLIPVOLUME& cv)
{
   DWORD zones[4] = {0, 0, 0, 0};
   FLOAT x, y, z;
   float temp;

   for(int i = 0; i < 4; i++)
   {
      x = pNode->arBounds[i].x;
      y = pNode->arBounds[i].y;
      z = pNode->arBounds[i].z;

      temp = cv.pNear.a * x + cv.pNear.b * y + cv.pNear.c * z + cv.pNear.d;
      if (temp > CULL_TOLERANCE) {
         zones[i] |= 0x01;
      }
      else {
            temp = cv.pFar.a * x + cv.pFar.b * y + cv.pFar.c * z + cv.pFar.d;
            if (temp > CULL_TOLERANCE) {
               zones[i] |= 0x02;
            }
      }

      temp = cv.pLeft.a * x + cv.pLeft.b * y + cv.pLeft.c * z + cv.pLeft.d;
      if (temp > CULL_TOLERANCE) {
         zones[i] |= 0x04;
      }
      else {
           temp = cv.pRight.a * x + cv.pRight.b * y + cv.pRight.c * z + cv.pRight.d;
           if (temp > CULL_TOLERANCE) {
             zones[i] |= 0x08;
           }
      }

      temp = cv.pTop.a * x + cv.pTop.b * y + cv.pTop.c * z + cv.pTop.d;
      if (temp > CULL_TOLERANCE+2.0f) {
         zones[i] |= 0x10;
      }
      else
      {
         temp = cv.pBottom.a * x + cv.pBottom.b * y + cv.pBottom.c * z + cv.pBottom.d;
         if (temp > CULL_TOLERANCE) {
            zones[i] |= 0x20;
         }
      }
   }

   //if all of the corners are outside of the boundaries
   // this node is excluded, so stop traversing
   DWORD res = zones[0] & zones[1] & zones[2] & zones[3];
   if(res)
   {
      return -1;
   }

   // if this is a leaf add the triangle lists to the render queue
   if (pNode->ntType == LEAF_TYPE)
   {
      pNode->bVis = TRUE;
      m_arVisQuads.push_back(pNode);
      return 1;
   }
   else
   {
      //this is not a leaf traverse deeper
      for(i = 0; i < 4; i++) {
         CullTerrain(pNode->pBranches[i], cv);
      }
   }
   return 0;
}

Princip metody spočívá v tom, že zkoumáme všechny čtyři krajní body každého uzlu a testujeme, zda-li jsou uvnitř Frustum nebo ne. Pokud je alespoň jeden bod uvnitř, považujeme uzel za viditelný a pokud se jedná o list, přidáme ho do pole m_arVisQuads. V opačném případě voláme metody CullTerrain() pro všechny potomky.
Ještě se vrátím k testu. Zde konečně využijeme naší novou strukturu CLIPVOLUME. Postupně vezmeme všechny stěny Frustum a dosazujeme krajní body uzlu. Pokud by bod ležel přesně v rovině (což se ve světe floatů prakticky nemůže stát), vyšel by výsledek 0. Nás ale zajímá situace, kdy je bod venku (uvnitř). Pak vyjde výsledek kladný (v našem případě používáme konstantu CULL_TOLERANCE, pomocí které můžeme řídit přesah) a to zaznamenáme v poli zones, kam se postupně přidává informace o bodech, které jsou mimo. Pokud jsou mimo všechny, metoda se ukončí.

Na závěr si ještě ukážeme vykreslovací metodu Render().

HRESULT CTerrain::Render()
{

IDisplay *pDis;
CLIPVOLUME cv;
PIXEL v;
int i;
char szInfo[255];
CreateDisplayObject(DISIID_IDisplay, (void**) &pDis);

if(m_dwFlags & TF_DRAWQUADSMAP)
{
   for(i = 0; i < (int)m_arLeaves.size(); i++)
   {
      ((QTNode*)m_arLeaves[i])->bVis = FALSE;
   }
}

m_arVisQuads.clear();
pDis->GetCamera()->GetClipVolume(cv);
CullTerrain(m_pRoot, cv);

pDis->GetDevice()->SetVertexShader(VERTEXFORMAT);
pDis->GetDevice()->SetIndices(m_pTerrainIB->GetBuffer(), 0);
pDis->GetDevice()->SetTexture(0, m_pTerrainSurface->GetTexture());

if(m_dwFlags & TF_USEQUADS)
{
   for(i = 0; i < (int)m_arVisQuads.size(); i++)
   {
      pDis->GetDevice()->SetStreamSource(0,((QTNode*)m_arVisQuads[i])->pVB->GetBuffer(),
                                        sizeof(VERTEX));
      pDis->GetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,LEAF_V_SIZE*LEAF_V_SIZE,0,
                                              LEAF_I_SIZE*LEAF_I_SIZE * 2);
   }
   sprintf(szInfo, "Using quad tree culling\nTotal leaves: %d\nTotal faces: %d",
          (int)m_arVisQuads.size(),(int)m_arVisQuads.size() * LEAF_I_SIZE * LEAF_I_SIZE * 2);
}
else
{
   for(i = 0; i < (int)m_arLeaves.size(); i++)
   {
      pDis->GetDevice()->SetStreamSource(0, ((QTNode*)m_arLeaves[i])->pVB->GetBuffer(),
                                           sizeof(VERTEX));
      pDis->GetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,LEAF_V_SIZE*LEAF_V_SIZE,0,                                           LEAF_I_SIZE*LEAF_I_SIZE * 2);
   }
   sprintf(szInfo, "Without quad tree culling\nTotal leaves: %d\nTotal faces: %d",
          (int)m_arLeaves.size(), (int)m_arLeaves.size() * LEAF_I_SIZE * LEAF_I_SIZE * 2);
}

if(m_dwFlags & TF_DRAWQUADSMAP)
{
   pDis->GetDevice()->SetVertexShader(PIXELFORMAT);
   pDis->GetDevice()->SetRenderState(D3DRS_LIGHTING, FALSE);
   pDis->GetDevice()->SetTexture(0, NULL);
   for(i = 0; i < (int)m_arLeaves.size(); i++)
   {
      QTNode *pNode = (QTNode*)m_arLeaves[i];
      v.vecPos.x = pNode->arBounds[0].x/LEAF_I_SIZE +
                   pDis->GetResolution()->x - m_iTerrainTilesX/LEAF_I_SIZE - 10;
      v.vecPos.y = pNode->arBounds[0].y/LEAF_I_SIZE + 10;
      v.vecPos.z = 0.0f;
      v.rhw = 1.0f;
      if(pNode->bVis)
      {
         v.dwDiffuse = D3DCOLOR_ARGB(255,255,255,0);
      }
      else
      {
         v.dwDiffuse = D3DCOLOR_ARGB(255,128,128,128);
      }
      pDis->GetDevice()->DrawPrimitiveUP(D3DPT_POINTLIST, 1, &v, sizeof(PIXEL));
   }
   pDis->GetDevice()->SetRenderState(D3DRS_LIGHTING, TRUE);
}

m_pDebugFont->Draw(szInfo, 0, 300);

SAFE_RELEASE(pDis);
return 0;

}

Pokud máme aktivní mapu, je třeba vymazat viditelnost všech listů. V opačném případě atribut bVis vůbec k ničemu nepoužíváme, takže tuto smyčku můžeme přeskočit. Dále použijeme objekt CLIPVOLUME z naší kamery a provedeme ořezání metodou CullTerrain().

Před vykreslením musíme nastavit známé parametry jako formát vertexů, texturu a index bufferu. Poté se rozhoduje, jakým způsobem budeme listy vykreslovat. Pokud je zapnutá optimalizace, vykreslují se pouze viditelné listy z pole m_arVisQuads. V opačném případě se vykreslí všechny listy z pole m_arLeaves.

V poslední části vykreslujeme mapu (pokud o to uživatel stojí). Mapa je tvořena v pravém horním rohu a zatím ji vykreslujeme po pixelech. každý pixel představuje list. Viditelné jsou žluté, ostatní šedé. Používáme k tomu transformované vrcholy PIXEL, u nichž nastavujeme pouze polohu (přímo v souřadnicích obrazovky) a barvu.

Na závěr vykreslíme informace o terénu. Vypisuje se pouze počet viditelných listů a celkový počet polygonů.

30.3. Závěr

A co nás čeká v příští lekci? Dále budeme zdokonalovat náš jednoduchý engine. Například přidáme oblohu a podíváme se, jak dále upravit a zrychlit vykreslovaní terénu (optimalizovat lze téměř donekonečna). Dále bych chtěl vylepšit podporu světel. Budou to tedy spíše takové "kosmetické" změny než revoluce, kterou jste viděli dnes.

Název	Popis
GenerateTerrain(int x, int y, TERRAIN_METHOD tmMethod);	Generuje náhodný terén požadovanou metodou o daných rozměrech. Inicializuje proměnné m_iTerrainTilesX, m_iTerrainTilesY, m_iTerrainVerticesX, m_iTerrainVerticesY a vytvoří pole m_arTerrain. Ukládá metodu terénu: m_iTerrainMethod.
GenerateTerrainFromFile(LPCSTR szFile);	Generuje terén z heightmapy dané parametrem. Inicializuje proměnné m_iTerrainTilesX, m_iTerrainTilesY, m_iTerrainVerticesX, m_iTerrainVerticesY a vytvoří pole m_arTerrain. Dále načte heightmapu a ukazatel uloží do m_pHeightMap. Ukládá metodu terénu: m_iTerrainMethod.
DestroyTerrain();	Odstraní terén z paměti (uvolní se všechny pomocné objekty, textury, VB a IB).
GetTitlesX()	Vrací velikost terénu ve směru x.
GetTitlesY()	Vrací velikost terénu ve směru y.
SetFlag(DWORD dwFlag)	Nastaví daný příznak. Modifikuje proměnnou m_dwFlags.
UnsetFlag(DWORD dwFlag)	Vynuluje příznak. Modifikuje proměnnou m_dwFlags.
InvertFlag(DWORD dwFlag)	Invertuje příznak. Modifikuje proměnnou m_dwFlags.
ResetFlags()	Vynuluje všechny příznaky. Modifikuje proměnnou m_dwFlags.
Render()	Provede oříznutí viditelných listů a vykreslí terén, případně mapu. Metoda by měla být volána v bloku BeginScene()-EndScene().
Restore()	Obnoví všechny zdroje po ztrátě zařízení (textury, IB a VB jednotlivých listů).
InternalInit()	Alokuje některé zdroje společné pro oba typy tvorby terénu. Jedná se o texturu povrchu: m_pTerrainSurface, index buffer listů m_pTerrainIB a font m_pDebugFont.
CreateNode(QTNode *pNode)	Rekurzivní metoda vytvářející strukturu quad tree.
FillLeaves()	Naplní listy stromu daty, zkopíruje tedy vrcholy terénu do dílčích VB.
DestroyNode(QTNode *pNode)	Zcela uvolní paměť stromu tj. vymaže všechny uzle a listy i s jejich VB.
CircleAlgorithm()	Aplikuje algoritmus kopečků (viz. minulá lekce)).
ComputeNormals()	Spočítá normály celého terénu. Opět jsme tento postup probírali v minulé lekci.
CreateQuadTree()	Vytvoří celý quad tree. Nejprve tedy zinicializuje kořen stromu a poté spustí metody CreateNode().
CullTerrain(QTNode *pNode, CLIPVOLUME& cv)	Zajistí ořezávání terénu tzn. naplní pole viditelných listů.

Kurz DirectX (30.)

30.1. Frustum

30.2. Třída CTerrain

30.3. Závěr