Octree

 

如果是储存面索引的方法,那么就比原来的实现有些复杂,不过原理还是一样的。

假设所有的物体都是从3DS模型中读入的,我们首先要把物体的基本的数据结构搞清楚。

struct tFace //面

{

     int vertIndex[3];           // 三个顶点

     int coordIndex[3];          // 顶点的纹理坐标

};

struct t3DObject //物体

{

     int  numOfVerts;            // 顶点总数

     int  numOfFaces;            // 面的数目

     int  numTexVertex;          // 纹理坐标的数目

     int  materialID;            // 纹理ID, 通过引用纹理数组的索引引用

     bool bHasTexture;           //

     char strName[255];          // 物体的名字

     UINT      *pIndices;        // 物体的面索引,用于vertex arrays

     CVector3  *pVerts;          // 顶点的指针

     CVector3  *pNormals;        // 物体的法线

     tVector2  *pTexVerts;       // 纹理的UV 坐标

     tFace *pFaces;              // 面

}

 

struct tFaceList

{

     vector<bool> pFaceList;

     int totalFaceCount;

};

和前面一样,建立八叉树前先要获取世界的长宽高,然后把它作为根节点的信息传递给CreateNode函数。

由于我们读入的模型中可能包括很多物体,所以我们需要改变一下,把原来用于保存顶点的vector<bool>改成 vector<tFaceList>,其实也就多了一行代码。

vector<tFaceList> pList1(pWorld->numOfObjects);         // TOP_LEFT_FRONT node

         vector<tFaceList> pList2(pWorld->numOfObjects);         // TOP_LEFT_BACK node

         vector<tFaceList> pList3(pWorld->numOfObjects);         // TOP_RIGHT_BACK node           vector<tFaceList> pList4(pWorld->numOfObjects);        // TOP_RIGHT_FRONT node

         vector<tFaceList> pList5(pWorld->numOfObjects);         // BOTTOM_LEFT_FRONT node

         vector<tFaceList> pList6(pWorld->numOfObjects);         // BOTTOM_LEFT_BACK node

         vector<tFaceList> pList7(pWorld->numOfObjects);         // BOTTOM_RIGHT_BACK node

     vector<tFaceList> pList8(pWorld->numOfObjects);        // BOTTOM_RIGHT_FRONT node

现在我们需要检测每个物体的每个三角形位于哪个位置,和前面的例子,这只是换汤不换药:

         for(int i = 0; i < pWorld->numOfObjects; i++) //遍历世界的每一个物体

         {

              t3DObject *pObject = &(pWorld->pObject[i]); //当前物体

              //调整容器的容量

              pList1[i].pFaceList.resize(pObject->numOfFaces);

              pList2[i].pFaceList.resize(pObject->numOfFaces);

              pList3[i].pFaceList.resize(pObject->numOfFaces);

              pList4[i].pFaceList.resize(pObject->numOfFaces);

              pList5[i].pFaceList.resize(pObject->numOfFaces);

              pList6[i].pFaceList.resize(pObject->numOfFaces);

              pList7[i].pFaceList.resize(pObject->numOfFaces);

              pList8[i].pFaceList.resize(pObject->numOfFaces);

 

              for(int j = 0; j < pObject->numOfFaces; j++)//遍历该物体中所有的三角形

              {

                   for(int whichVertex = 0; whichVertex < 3; whichVertex++)

                   {

                       // 当前顶点

                       CVector3 vPoint = pObject->pVerts[pObject->pFaces[j].vertIndex[whichVertex]];

 

                       // 看是否在 TOP LEFT FRONT node

                       if( (vPoint.x <= vCtr.x) && (vPoint.y >= vCtr.y) && (vPoint.z >= vCtr.z) )

                            pList1[i].pFaceList[j] = true;

 

                       //看是否在TOP LEFT BACK

                       if( (vPoint.x <= vCtr.x) && (vPoint.y >= vCtr.y) && (vPoint.z <= vCtr.z) )

                            pList2[i].pFaceList[j] = true;

 

                       //看是否在TOP RIGHT BACK

                       if( (vPoint.x >= vCtr.x) && (vPoint.y >= vCtr.y) && (vPoint.z <= vCtr.z) )

                            pList3[i].pFaceList[j] = true;

 

                       //看是否在TOP RIGHT FRONT

                       if( (vPoint.x >= vCtr.x) && (vPoint.y >= vCtr.y) && (vPoint.z >= vCtr.z) )

                            pList4[i].pFaceList[j] = true;

 

                       //看是否在BOTTOM LEFT FRONT

                       if( (vPoint.x <= vCtr.x) && (vPoint.y <= vCtr.y) && (vPoint.z >= vCtr.z) )

                            pList5[i].pFaceList[j] = true;

 

                       //看是否在BOTTOM LEFT BACK

                       if( (vPoint.x <= vCtr.x) && (vPoint.y <= vCtr.y) && (vPoint.z <= vCtr.z) )

                            pList6[i].pFaceList[j] = true;

 

                       //看是否在BOTTOM RIGHT BACK

                       if( (vPoint.x >= vCtr.x) && (vPoint.y <= vCtr.y) && (vPoint.z <= vCtr.z) )

                            pList7[i].pFaceList[j] = true;

 

                       //看是否在BOTTOM RIGHT FRONT

                       if( (vPoint.x >= vCtr.x) && (vPoint.y <= vCtr.y) && (vPoint.z >= vCtr.z) )

                            pList8[i].pFaceList[j] = true;

                   }

              }   

 

              // 接下来我们要把每个小区域内部的三角形的数目数出来

             

              pList1[i].totalFaceCount = 0;        pList2[i].totalFaceCount = 0;

              pList3[i].totalFaceCount = 0;        pList4[i].totalFaceCount = 0;

              pList5[i].totalFaceCount = 0;        pList6[i].totalFaceCount = 0;

              pList7[i].totalFaceCount = 0;        pList8[i].totalFaceCount = 0;

         }

知道了三角形的数目我们就可以调用CreateNewNode了:

         for(i = 0; i < pWorld->numOfObjects; i++)

         {

              //便利所有物体的三角形

              for(int j = 0; j < pWorld->pObject[i].numOfFaces; j++)

              {

                   if(pList1[i].pFaceList[j])  { pList1[i].totalFaceCount++; triCount1++; }

                   if(pList2[i].pFaceList[j])  { pList2[i].totalFaceCount++; triCount2++; }

                   if(pList3[i].pFaceList[j])  { pList3[i].totalFaceCount++; triCount3++; }

                   if(pList4[i].pFaceList[j])  { pList4[i].totalFaceCount++; triCount4++; }

                   if(pList5[i].pFaceList[j])  { pList5[i].totalFaceCount++; triCount5++; }

                   if(pList6[i].pFaceList[j])  { pList6[i].totalFaceCount++; triCount6++; }

                   if(pList7[i].pFaceList[j])  { pList7[i].totalFaceCount++; triCount7++; }

                   if(pList8[i].pFaceList[j])  { pList8[i].totalFaceCount++; triCount8++; }

              }

         }

 

         CreateNewNode(pWorld, pList1, triCount1, vCenter, width, TOP_LEFT_FRONT);

         CreateNewNode(pWorld, pList2, triCount2, vCenter, width, TOP_LEFT_BACK);

         CreateNewNode(pWorld, pList3, triCount3, vCenter, width, TOP_RIGHT_BACK);

         CreateNewNode(pWorld, pList4, triCount4, vCenter, width, TOP_RIGHT_FRONT);

         CreateNewNode(pWorld, pList5, triCount5, vCenter, width, BOTTOM_LEFT_FRONT);

         CreateNewNode(pWorld, pList6, triCount6, vCenter, width, BOTTOM_LEFT_BACK);

         CreateNewNode(pWorld, pList7, triCount7, vCenter, width, BOTTOM_RIGHT_BACK);

     CreateNewNode(pWorld, pList8, triCount8, vCenter, width, BOTTOM_RIGHT_FRONT);

现在CreateNewNode有了较大的改变,参数还是一样,在调用CreateNode之前,我们需要做一些工作,这些工作是要确定面列表,到最后把它传给显示列表:

 

void COctree::CreateNewNode(t3DModel *pWorld, vector<tFaceList> pList, int triangleCount,

                                CVector3 vCenter, float width,                int nodeID)

{

     if(!triangleCount) return;

     //临时变量,并初始化,保存叶结点中所有的物体

     t3DModel *pTempWorld = new t3DModel;

     memset(pTempWorld, 0, sizeof(t3DModel));

     pTempWorld->numOfObjects = pWorld->numOfObjects;

    

     // 遍历由参数传递进来的分区的所有物体

     for(int i = 0; i < pWorld->numOfObjects; i++)

     {

         t3DObject *pObject = &(pWorld->pObject[i]);

         // Create a new object, initialize it, then add it to our temp partition

         t3DObject newObject;

         memset(&newObject, 0, sizeof(t3DObject));

         pTempWorld->pObject.push_back(newObject);

 

         // Assign the new node's face count, material ID, texture boolean and

         // vertices to the new object.  Notice that it's not that pObject's face

         // count, but the pList's.  Also, we are just assigning the pointer to the

         // vertices, not copying them.

         pTempWorld->pObject[i].numOfFaces  = pList[i].totalFaceCount;

         pTempWorld->pObject[i].materialID  = pObject->materialID;

         pTempWorld->pObject[i].bHasTexture = pObject->bHasTexture;

         pTempWorld->pObject[i].pVerts      = pObject->pVerts;

 

         pTempWorld->pObject[i].pFaces = new tFace [pTempWorld->pObject[i].numOfFaces];//建立空的面列表

         int index = 0;

         // 遍历所有的面,如果在节点内,就保存面到面列表

         for(int j = 0; j < pObject->numOfFaces; j++)

         {

              if(pList[i].pFaceList[j])  

              {

                   pTempWorld->pObject[i].pFaces[index] = pObject->pFaces[j];

                   index++;

              }

         }

     }

这里我们做的所有的工作都是为了这个pTempWorld,这是一个临时变量,保存了当前分区的所有物体,接下来要做的就是为新的节点分配内存

 

 

m_pOctreeNodes[nodeID] = new COctree;

     CVector3 vNodeCenter = GetNewNodeCenter(vCenter, width, nodeID);

     g_CurrentSubdivision++;

     m_pOctreeNodes[nodeID]->CreateNode(pTempWorld, triangleCount, vNodeCenter, width / 2);

g_CurrentSubdivision--;

最后一步释放临时变量:

// 遍历临时变量的所有物体,释放前面创建的面列表

     for(i = 0; i < pWorld->numOfObjects; i++)

     {

         if(pTempWorld->pObject[i].pFaces)

              delete [] pTempWorld->pObject[i].pFaces;

     }

     delete pTempWorld;

 

到现在为止我们还没有把面索引的信息拷贝给叶结点,这个工作的思想是,对叶结点的分区的每一个物体遍历,把物体的每一个面(三角形)的三个顶点按顺序储存在一个数组里面,每一个物体都持有这样的一个数组

AssignTrianglesToNode(t3DModel *pWorld, int numberOfTriangles)

{

     //我们把pWorld分区的信息传递给面列表,它保存了我们渲染需要的面索引,由于我们使用顶点数组的缘故我们不能使用tFace结构作为索引的值,我们需要建立这样一个数组,他连续的保存了面索引。这就是pIndices数组,他的型别是无符号整数,必须是无符号整数。

     m_bSubDivided = false;

     m_TriangleCount = numberOfTriangles;

     m_pWorld = new t3DModel;

     memset(m_pWorld, 0, sizeof(t3DModel));

 

     // Assign the number of objects to our face index list

     m_pWorld->numOfObjects = pWorld->numOfObjects;

     // Go through all of the objects in the partition that was passed in

     for(int i = 0; i < m_pWorld->numOfObjects; i++)

     {

         // Create a pointer to the current object

         t3DObject *pObject = &(pWorld->pObject[i]);

 

         // Create and init a new object to hold the face index information

         t3DObject newObject;

         memset(&newObject, 0, sizeof(t3DObject));

 

         // If this object has face information, add it's index to our object index list

         if(pObject->numOfFaces)

              AddObjectIndexToList(i); //为每个物体建立索引

 

         // Add our new object to our face index list

         m_pWorld->pObject.push_back(newObject);

         int numOfFaces = pObject->numOfFaces;

         m_pWorld->pObject[i].numOfFaces = numOfFaces;

 

         // 为面索引分配空间  pIndices将传递给顶点数组. 

         m_pWorld->pObject[i].pFaces = new tFace [numOfFaces];

         m_pWorld->pObject[i].pIndices = new UINT [numOfFaces * 3];

 

         // 初始化

         memset(m_pWorld->pObject[i].pIndices, 0, sizeof(UINT) * numOfFaces * 3);

         // 拷贝面信息

         memcpy(m_pWorld->pObject[i].pFaces, pObject->pFaces, sizeof(tFace) * numOfFaces);

 

         // 由于使用顶点数组,我们需要一个储存了所有的面信息的数组,这将作为参数传递给

         // glDrawElements(). 

         // Go through all the faces and assign them in a row to our pIndices array

         for(int j = 0; j < numOfFaces * 3; j += 3)

         {

     m_pWorld->pObject[i].pIndices[j]     = m_pWorld->pObject[i].pFaces[j / 3].vertIndex[0];

     m_pWorld->pObject[i].pIndices[j + 1] = m_pWorld->pObject[i].pFaces[j / 3].vertIndex[1];

     m_pWorld->pObject[i].pIndices[j + 2] = m_pWorld->pObject[i].pFaces[j / 3].vertIndex[2];

         }

 

         // 我们只需要使用pIndcies,所以释放不需要的变量

         delete [] m_pWorld->pObject[i].pFaces;

         m_pWorld->pObject[i].pFaces = NULL;

     }

     m_DisplayListID = g_EndNodeCount;

     g_EndNodeCount++;

}

到此,每个物体的面索引就都储存在每个物体内部的pIndices数组内,这个数组最终将作为顶点数组渲染的对象。

为了使程序看上去完整,顺带把显示列表也提一下,我们将为每个叶结点分配一个显示列表的ID,每个叶结点中的物体保存了pIndices数组,在构造显示列表的时候用顶点数组来实现立即绘制:

CreateDisplayList(COctree *pNode, t3DModel *pRootWorld, int displayListOffset)

{

     if(!pNode) return;

     // 检查是不是叶结点,如果不是就深入

     if(pNode->IsSubDivided())

     {

         // Recurse down to each one of the children until we reach the end nodes

CreateDisplayList(pNode->m_pOctreeNodes[TOP_LEFT_FRONT],     pRootWorld, displayListOffset);

CreateDisplayList(pNode->m_pOctreeNodes[TOP_LEFT_BACK],      pRootWorld, displayListOffset);

CreateDisplayList(pNode->m_pOctreeNodes[TOP_RIGHT_BACK],     pRootWorld, displayListOffset);

CreateDisplayList(pNode->m_pOctreeNodes[TOP_RIGHT_FRONT],    pRootWorld, displayListOffset);

CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_LEFT_FRONT],  pRootWorld, displayListOffset);

CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_LEFT_BACK],   pRootWorld, displayListOffset);

CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_RIGHT_BACK],  pRootWorld, displayListOffset);

CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_RIGHT_FRONT],pRootWorld, displayListOffset);

     }

     else

     {

         if(!pNode->m_pWorld) return;

         // 显示列表的ID偏移量

         pNode->m_DisplayListID += displayListOffset;

//********************************建立显示列表开始*****************************************

         // Start the display list and assign it to the end nodes ID

         glNewList(pNode->m_DisplayListID,GL_COMPILE);

         // 储存物体数量

         int counter = 0;

         // Store the object count and material count in some local variables for optimization

         int objectCount = pNode->m_pObjectList.size(); //物体数量

         int materialCount = pRootWorld->pMaterials.size(); //材质数量

 

         // 遍历所有物体

         while(counter < objectCount)

         {

              // Get the first object index into our root world

              // 取得整个世界中第一个物体的索引

              int i = pNode->m_pObjectList[counter];

 

              // Store pointers to the current face list and the root object

              // that holds all the data (verts, texture coordinates, normals, etc..)

              // 保存指向现在的面列表的指针和整个世界的指针,他们包含了所有的数据

              t3DObject *pObject     = &pNode->m_pWorld->pObject[i];

              t3DObject *pRootObject = &pRootWorld->pObject[i];

 

              // Check to see if this object has a texture map, if so, bind the texture to it.

              // 检查当前物体是否包括贴图,如果有,邦定贴图

              if(pRootObject->bHasTexture)

              {

                   // Turn on texture mapping and turn off color

                   glEnable(GL_TEXTURE_2D);

                   // Reset the color to normal again

                   glColor3ub(255, 255, 255);

                   glBindTexture(GL_TEXTURE_2D, g_Texture[pRootObject->materialID]);

              }

              else

              {

                   glDisable(GL_TEXTURE_2D);

                   glColor3ub(255, 255, 255);

              }

 

              // Check to see if there is a valid material assigned to this object

              // 检查材质

              if(materialCount && pRootObject->materialID >= 0)

              {

                   // Get and set the color that the object is, since it must not have a texture

                   BYTE *pColor = pRootWorld->pMaterials[pRootObject->materialID].color;

 

                   // Assign the current color to this model

                   glColor3ub(pColor[0], pColor[1], pColor[2]);

              }

              // Make sure we have texture coordinates to render

              // 是否有纹理坐标,如果有,需要启用纹理坐标数组

              if(pRootObject->pTexVerts)

              {

                   // Turn on the texture coordinate state

                   glEnableClientState(GL_TEXTURE_COORD_ARRAY);

                   glTexCoordPointer(2, GL_FLOAT, 0, pRootObject->pTexVerts);

              }

 

              // Make sure we have vertices to render

              // 确定是否有顶点等待渲染,如果有建立顶点数组

              if(pRootObject->pVerts)

              {

                   glEnableClientState(GL_VERTEX_ARRAY);

                   glVertexPointer(3, GL_FLOAT, 0, pRootObject->pVerts);  // pRootObject->pVerts指向顶点数组

              }

 

              // Make sure we have normals to render

              // 确定是否有法线需要渲染,如果有建立法线数组

              if(pRootObject->pNormals)

              {

                   // Turn on the normals state

                   glEnableClientState(GL_NORMAL_ARRAY);

                   glNormalPointer(GL_FLOAT, 0, pRootObject->pNormals);

              }

              // 注意,这里的pObject是  &pNode->m_pWorld->pObject[i];

              glDrawElements(GL_TRIANGLES,    pObject->numOfFaces * 3,

                               GL_UNSIGNED_INT, pObject->pIndices);

              counter++;

         }

 

         // End the display list for this ID

         glEndList();

//********************************建立显示列表结束****************************************

 

     }

}

最后一步,把八叉树画出来,思想也很简单,首先深入到叶结点,然后执行显示列表,当然,在最开始还是要判断以下视景体所在的位置:

DrawOctree(COctree *pNode, t3DModel *pRootWorld)

{

     if(!pNode) return;

     if(!g_Frustum.CubeInFrustum(pNode->m_vCenter.x, pNode->m_vCenter.y,

                                     pNode->m_vCenter.z, pNode->m_Width / 2) )

     {

         return;

     }

     if(pNode->IsSubDivided())

     {

         // Recurse to the bottom of these nodes and draw the end node's vertices

         // Like creating the octree, we need to recurse through each of the 8 nodes.

         DrawOctree(pNode->m_pOctreeNodes[TOP_LEFT_FRONT],       pRootWorld);

         DrawOctree(pNode->m_pOctreeNodes[TOP_LEFT_BACK],        pRootWorld);

         DrawOctree(pNode->m_pOctreeNodes[TOP_RIGHT_BACK],       pRootWorld);

         DrawOctree(pNode->m_pOctreeNodes[TOP_RIGHT_FRONT],      pRootWorld);

         DrawOctree(pNode->m_pOctreeNodes[BOTTOM_LEFT_FRONT],    pRootWorld);

         DrawOctree(pNode->m_pOctreeNodes[BOTTOM_LEFT_BACK],     pRootWorld);

         DrawOctree(pNode->m_pOctreeNodes[BOTTOM_RIGHT_BACK],    pRootWorld);

         DrawOctree(pNode->m_pOctreeNodes[BOTTOM_RIGHT_FRONT],   pRootWorld);

     }

     else

     {

         // Increase the amount of nodes in our viewing frustum (camera's view)

         g_TotalNodesDrawn++;

         // Make sure we have valid data assigned to this node

         if(!pNode->m_pWorld) return;

         // Call the list with our end node's display list ID

         glCallList(pNode->m_DisplayListID);

 

     }

}

你可能感兴趣的:(list,object,delete,float,optimization,Pointers)