Optimizing 3D tile engine

  
// Unoptimized

something **Tiles = ...;
for(int x=0; x<width; x++) {
  for(int y=0; y<height; y++) {
    render(&Tiles[x][y]);
  }
}
// Somewhat Optimized

something *Tiles = ...;
something *Cur = &Tile[0];
int max = width*height;
for(int a=0; a<max; a++, Cur++) {
  render(Cur);
}
// More optimized

something *Tiles = ...;
something *Cur = &Tile[0];
for(something *Last = &Tile[width * height]; (unsigned)Cur<(unsigned)Last; Cur++) {
  render(Cur);
}
  

  
class MapTile {
public:
   int Terrain;
   int Object;
   int NPC;
   MapTile * Next;
   void DisplayTile(CMap* map);
   inline MapTile();
   inline ~MapTile();
};

class CMap: public CRendered {
private:
   MapTile** MapArray;
   CTextureNode* Textures;
   int NumTextures;
   int Resolutionx,Resolutiony;
   int TamX,TamY;   
public:
   void InitMap(); 
   void DrawMap();
   inline CMap(int tamx, int tamy);
   inline ~CMap();
   int GetTamX() { return TamX;}
   int GetTamY() { return TamY;}
   void InitTextureTable(int num);
   void AddTexture(int num, char* name);
   bool IsLoaded(int num);
   TextureImage* GetTexture(int num);
   void CreateRandomMap();
   void Update(float Delta) {};
   void Draw() {
      DrawMap();
   }
}; 

  

  
enum {cOutsideFrustrum = 0, cPartiallyInside, cFullyInside};

void MyRenderer::renderWorld()
{

  MapQuadTreeNode* currentNode = world->getBoundingQuadtree()->GetRootNode;
  long RootClipHint = ClipCubeToFrustrum(currentNode);

  if (RootClipHint == cOutsideFrustrum)  // Nothing to Draw at all?

      return;

  if (RootClipHint == cFullyInside)  // Everything visible?

  {
      DrawAllTilesInNode(currentNode);
      return;
  }

  // Hmm, only part of the map can been seen.. let's find out

  // which parts we want to draw


  RenderWorldChildNodes(currentNode)

}

void MyRenderer::RenderWorldChildNodes(MapQuadTreeNode *parentNode)
{

   // Is this the bottom node?? then we render it because

   // we are only called if we know that some of the tiles

   // we contained are visible on the screen


   if (parentNode->hasChildNodes == false)
   {
      DrawAllTilesInNode(parentNode);
      return;
   }

   MapQuadTreeNode *ChildNode;
   long ClipHint;

   // ----------------------------------

   // Process the upper left child node


   ChildNode = parentNode->getUpperLeftChild();
   ClipHint = ClipCubeToFrustrum(ChildNode);

   // Is everything on screen?


   if (ClipHint == cFullyInside)  // Everything visible?

   {
      DrawAllTilesInNode(ChildNode);
   }
  
   // Is it only partially on screen?

   // The recurse down and check its sub nodes


   if (ClipHint == cPartiallyInside)
   {
     RenderWorldChildNodes(currentNode);  
   }

   // If it is not visible (cOutsideFrustrum), then    

   // We do nothing :-)


   // ----------------------------------

   // Process the upper right child node


   ChildNode = parentNode->getUpperRightChild();
   ClipHint = ClipCubeToFrustrum(ChildNode);

   // Is everything on screen?


   if (ClipHint == cFullyInside)  // Everything visible?

   {
      DrawAllTilesInNode(ChildNode);
   }
  
   // Is it only partially on screen?

   // The recurse down and check its sub nodes


   if (ClipHint == cPartiallyInside)
   {
     RenderWorldChildNodes(currentNode);  
   }

   // If it is not visible (cOutsideFrustrum), then    

   // We do nothing :-)


   // ----------------------------------

   //  And repeat for lower left and right nodes...


   ... code goes here ...  exercuise for the reader ...

}