..: 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. Frustrum

O frustrum 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 frustrum 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 frustrum:

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Φφ frustrum 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 frustrum 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 frustrum 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 frustrum do skuteΦnΘ pozice kamery.

Nynφ u₧ bude hraΦka urΦit st∞ny frustrum, 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 frustrum 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∞ frustrum. 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():

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 frustrum. 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° frustrum 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 frustrum 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.

C/C++ & Visual C++

Kurz DirectX (30.)

30.1. Frustrum

30.2. T°φda CTerrain

30.3. Zßv∞r