速度是3D程序中最重要的指标，你必须限制绘制的多边形的个数，或者提高显卡绘制多边形的效率。显卡最近增加了一个新的扩展，叫做顶点缓存VS，它直接把顶点放置在显卡中的高速缓存中，极大的增加了绘制速度。
在这个教程里，我们会加载一个高度图，使用顶点数组高效的把网格数据发送到OpenGL里，并使用VBO扩展把顶点数据放入高效的显存里。
现在让我们开始吧，我们先来定义一些程序参数。
 
 
  

#define MESH_RESOLUTION 4.0f       // 每个顶点使用的像素#define MESH_HEIGHTSCALE 1.0f       // 高度的缩放比例//#define NO_VBOS        // 如果定义将不使用VBO扩展
// 定义VBO扩展它们在glext.h头文件中被定义#define GL_ARRAY_BUFFER_ARB 0x8892#define GL_STATIC_DRAW_ARB 0x88E4typedef void (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);typedef void (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);typedef void (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);typedef void (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
// VBO 扩展函数的指针
PFNGLGENBUFFERSARBPROC glGenBuffersARB = NULL; // 创建缓存名称
PFNGLBINDBUFFERARBPROC glBindBufferARB = NULL; // 绑定缓存
PFNGLBUFFERDATAARBPROC glBufferDataARB = NULL; // 绑定缓存数据
PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = NULL; // 删除缓存

  
 现在我们来定义自己的网格类：
 
  

class CVert              // 顶点类
{
public:
 float x;             
 float y;             
 float z;             
};
typedef CVert CVec;            

class CTexCoord             // 纹理坐标类
{
public:
 float u;             
 float v;             
};

//网格类
class CMesh
{
public:
 // 网格数据
 int    m_nVertexCount;        // 顶点个数
 CVert*   m_pVertices;        // 顶点数据的指针
 CTexCoord*  m_pTexCoords;        // 顶点的纹理坐标
 unsigned int m_nTextureId;        // 纹理的ID

 unsigned int m_nVBOVertices;        // 顶点缓存对象的名称
 unsigned int m_nVBOTexCoords;       // 顶点纹理缓存对象的名称

 AUX_RGBImageRec* m_pTextureImage;       // 高度数据

public:
 CMesh();             // 构造函数
 ~CMesh();             // 析构函数

 // 载入高度图
 bool LoadHeightmap( char* szPath, float flHeightScale, float flResolution );
 // 返回单个点的高度
 float PtHeight( int nX, int nY );
 // 创建顶点缓存对象
 void BuildVBOs();
};

  
 大部分代码都很简单，这里不多加解释。

下面我们来定义一些全局变量：
 
  

bool  g_fVBOSupported = false;       // 是否支持顶点缓存对象
CMesh*  g_pMesh = NULL;          // 网格数据
float  g_flYRot = 0.0f;         // 旋转角度
int   g_nFPS = 0, g_nFrames = 0;       // 帧率计数器
DWORD  g_dwLastFPS = 0;         // 上一帧的计数 

  
 下面的代码加载高度图,它和34课的内容差不多,在这里不多加解释了:  
  

//加载高度图
bool CMesh :: LoadHeightmap( char* szPath, float flHeightScale, float flResolution )
{

 FILE* fTest = fopen( szPath, "r" );       
 if( !fTest )            
  return false;           
 fclose( fTest );           

 // 加载图像文件
 m_pTextureImage = auxDIBImageLoad( szPath );    

 // 读取顶点数据
 m_nVertexCount = (int) ( m_pTextureImage->sizeX * m_pTextureImage->sizeY * 6 / ( flResolution * flResolution ) );
 m_pVertices = new CVec[m_nVertexCount];      
 m_pTexCoords = new CTexCoord[m_nVertexCount];    
 int nX, nZ, nTri, nIndex=0;         
 float flX, flZ;
 for( nZ = 0; nZ < m_pTextureImage->sizeY; nZ += (int) flResolution )
 {
  for( nX = 0; nX < m_pTextureImage->sizeX; nX += (int) flResolution )
  {
   for( nTri = 0; nTri < 6; nTri++ )
   {
    flX = (float) nX + ( ( nTri == 1 || nTri == 2 || nTri == 5 ) ? flResolution : 0.0f );
    flZ = (float) nZ + ( ( nTri == 2 || nTri == 4 || nTri == 5 ) ? flResolution : 0.0f );

    m_pVertices[nIndex].x = flX - ( m_pTextureImage->sizeX / 2 );
    m_pVertices[nIndex].y = PtHeight( (int) flX, (int) flZ ) *  flHeightScale;
    m_pVertices[nIndex].z = flZ - ( m_pTextureImage->sizeY / 2 );

    m_pTexCoords[nIndex].u = flX / m_pTextureImage->sizeX;
    m_pTexCoords[nIndex].v = flZ / m_pTextureImage->sizeY;

    nIndex++;
   }
  }
 }

 // 载入纹理，它和高度图是同一副图像
 glGenTextures( 1, &m_nTextureId );       
 glBindTexture( GL_TEXTURE_2D, m_nTextureId );    
 glTexImage2D( GL_TEXTURE_2D, 0, 3, m_pTextureImage->sizeX, m_pTextureImage->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, m_pTextureImage->data );
 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

 // 释放纹理数据
 if( m_pTextureImage )
 {
  if( m_pTextureImage->data )
   free( m_pTextureImage->data );
  free( m_pTextureImage );
 }
 return true;
}

  
 下面的代码用来计算(x,y)处的亮度 
  

//计算(x,y)处的亮度
float CMesh :: PtHeight( int nX, int nY )
{
 int nPos = ( ( nX % m_pTextureImage->sizeX )  + ( ( nY % m_pTextureImage->sizeY ) * m_pTextureImage->sizeX ) ) * 3;
 float flR = (float) m_pTextureImage->data[ nPos ];   // 返回红色分量
 float flG = (float) m_pTextureImage->data[ nPos + 1 ];  // 返回绿色分量
 float flB = (float) m_pTextureImage->data[ nPos + 2 ];  // 返回蓝色分量
 return ( 0.299f * flR + 0.587f * flG + 0.114f * flB );  // 计算亮度
}

  
 下面的代码把顶点数据绑定到顶点缓存，即把内存中的数据发送到显存  
  

void CMesh :: BuildVBOs(){ glGenBuffersARB( 1, &m_nVBOVertices );       // 创建一个顶点缓存，并把顶点数据绑定到缓存 glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOVertices );    glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_nVertexCount*3*sizeof(float), m_pVertices, GL_STATIC_DRAW_ARB );
glGenBuffersARB( 1, &m_nVBOTexCoords ); // 创建一个纹理缓存，并把纹理数据绑定到缓存
glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOTexCoords );
glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_nVertexCount*2*sizeof(float), m_pTexCoords, GL_STATIC_DRAW_ARB );

// 删除分配的内存
delete [] m_pVertices; m_pVertices = NULL;
delete [] m_pTexCoords; m_pTexCoords = NULL

  }

  
 好了，现在到了初始化的地方了。首先我将分配并载入纹理数据。接着检测是否支持VBO扩展。如果支持我们将把函数指针和它对应的函数关联起来，如果不支持将只返回数据。 
  

//初始化
BOOL Initialize (GL_Window* window, Keys* keys)     
{
 g_window = window;
 g_keys  = keys;

 // 载入纹理数据
 g_pMesh = new CMesh();          
 if( !g_pMesh->LoadHeightmap( "terrain.bmp",     
        MESH_HEIGHTSCALE,
        MESH_RESOLUTION ) )
 {
  MessageBox( NULL, "Error Loading Heightmap", "Error", MB_OK );
  return false;
 }

 // 检测是否支持VBO扩展
#ifndef NO_VBOS
 g_fVBOSupported = IsExtensionSupported( "GL_ARB_vertex_buffer_object" );
 if( g_fVBOSupported )
 {
  // 获得函数的指针
  glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) wglGetProcAddress("glGenBuffersARB");
  glBindBufferARB = (PFNGLBINDBUFFERARBPROC) wglGetProcAddress("glBindBufferARB");
  glBufferDataARB = (PFNGLBUFFERDATAARBPROC) wglGetProcAddress("glBufferDataARB");
  glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) wglGetProcAddress("glDeleteBuffersARB");
  // 创建VBO对象
  g_pMesh->BuildVBOs();         
 }
#else
 g_fVBOSupported = false;
#endif
 //设置OpenGL状态
 glClearColor (0.0f, 0.0f, 0.0f, 0.5f);      
 glClearDepth (1.0f);          
 glDepthFunc (GL_LEQUAL);         
 glEnable (GL_DEPTH_TEST);         
 glShadeModel (GL_SMOOTH);         
 glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);   
 glEnable( GL_TEXTURE_2D );         
 glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );      

 return TRUE;            
}

  
 下面的函数用来检测是否包含特定的扩展名称 
  

// 返回是否支持指定的扩展
bool IsExtensionSupported( char* szTargetExtension )
{
 const unsigned char *pszExtensions = NULL;
 const unsigned char *pszStart;
 unsigned char *pszWhere, *pszTerminator;

 pszWhere = (unsigned char *) strchr( szTargetExtension, ' ' );
 if( pszWhere || *szTargetExtension == '\0' )
  return false;

 // 返回扩展字符串
 pszExtensions = glGetString( GL_EXTENSIONS );

 // 在扩展字符串中搜索
 pszStart = pszExtensions;
 for(;;)
 {
  pszWhere = (unsigned char *) strstr( (const char *) pszStart, szTargetExtension );
  if( !pszWhere )
   break;
  pszTerminator = pszWhere + strlen( szTargetExtension );
  if( pszWhere == pszStart || *( pszWhere - 1 ) == ' ' )
   if( *pszTerminator == ' ' || *pszTerminator == '\0' )
    //如果存在返回True
    return true;
  pszStart = pszTerminator;
 }
 return false;
}

  
 好了,几乎结束了,我们下面来看看我们的渲染代码.
 
  

void Draw (void){ glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);   glLoadIdentity ();           
// 显示当前的帧率
if( GetTickCount() - g_dwLastFPS >= 1000 )
{
g_dwLastFPS = GetTickCount();
g_nFPS = g_nFrames;
g_nFrames = 0;

char szTitle[256]={0};
sprintf( szTitle, "Lesson 45: NeHe & Paul Frazee's VBO Tut - %d Triangles, %d FPS", g_pMesh->m_nVertexCount / 3, g_nFPS );
if( g_fVBOSupported ) // 是否支持VBO
strcat( szTitle, ", Using VBOs" );
else
strcat( szTitle, ", Not Using VBOs" );
SetWindowText( g_window->hWnd, szTitle ); // 设置窗口标题
}
g_nFrames++;

// 设置视口
glTranslatef( 0.0f, -220.0f, 0.0f );
glRotatef( 10.0f, 1.0f, 0.0f, 0.0f );
glRotatef( g_flYRot, 0.0f, 1.0f, 0.0f );

// 使用顶点，纹理坐标数组
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );

  
 为了使用VBO，你必须告诉OpenGL内存中的那部分需要加载到VBO中。所以第一步我们要起用顶点数组和纹理坐标数组。接着我们必须告诉OpenGL去把数据的指针设置到特定的地方，glVertexPointer函数可以完成这个功能。
我们分为启用和不启用VBO两个路径来渲染，他们都差不多，唯一的区别是当你需要把指针指向VBO缓存时，记得把数据指针设置NULL。
 
 
  

 // 如果支持VBO扩展 if( g_fVBOSupported ) {  glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh->m_nVBOVertices );  glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );  // 设置顶点数组的指针为顶点缓存  glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh->m_nVBOTexCoords );  glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );  // 设置顶点数组的指针为纹理坐标缓存 }  // 不支持VBO扩展 else {  glVertexPointer( 3, GL_FLOAT, 0, g_pMesh->m_pVertices );   glTexCoordPointer( 2, GL_FLOAT, 0, g_pMesh->m_pTexCoords );  }
  
 好了,渲染所有的三角形吧 
  

// 渲染 glDrawArrays( GL_TRIANGLES, 0, g_pMesh->m_nVertexCount );  
  
 最后,别忘了恢复到默认的OpenGL状态.  
  

 glDisableClientState( GL_VERTEX_ARRAY );     glDisableClientState( GL_TEXTURE_COORD_ARRAY );   }
  
 如果你想更多的了解VBO对象,我建议你读一下SGI的扩展说明:
http://oss.sgi.com/projects/ogl-sample/registry
它会给你更多的信息

好了,那就是这次的课程,如果你发现任何问题,请联系我.