glGenBuffersARB( 1, &vb_name );
   glBindBufferARB( GL_ARRAY_BUFFER_ARB, vb_name );
   glBufferDataARB( GL_ARRAY_BUFFER_ARB, mapx*mapy*sizeof(int)*3, terrain_vertexes, GL_STATIC_DRAW_ARB );
   
   glGenBuffersARB(1,&vbc_name);
   glBindBufferARB(GL_ARRAY_BUFFER_ARB,vbc_name);
   glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(float)*mapx*mapy*3,terrain_colors,GL_STATIC_DRAW_ARB);
   
   
   glVertexPointer(3,GL_INT,0,(char *)NULL);
   glColorPointer(3,GL_FLOAT,0,(char *)NULL);

You don't understand how VBO's work yet.

Unless you tell it, OpenGL doesn't know what is stored in a VBO; it's just an array of bytes. This array has no meaning until you call gl*Pointer on it. In doing so, you are telling OpenGL that, "Given the currently bound buffer, the * type of data begins at the given offset, with the given stride, and is of the given type."

As such, if you store your position data in "vb_name", then "vb_name" should be the bound buffer when you call glVertexPointer. The same is true for colors.

BTW, as a general rule, you shouldn't split buffers for different vertex attributes up unless there is a good reason for it (like one of them needs to be STREAM_DRAW, but the other only needs to be STATIC_DRAW). All you need to do is pass in the correct offset. Or, potentially better, you can interleve your data.

Yes, I made the other thread because I thought it might be more beneficial to learn the correct way to do vbo's before I actually implemented them.

But while you're here, I should point out that the Nehe example uses two arrays, one for vertices and the other for textures, and it runs just fine.

So that isn't where I'm losing my speed.

[edit]
And here's the new code that I am working with:
<code>
#define MAP_SCALE 4.0f
#define CLM_FAILED false
#define CLM_PASSED true
#define MOVEMENT_SIZE 4.0f
#define COLOR_CHANGE .90f
#define MAX_HEIGHT 255

#define RAD(n)(n/180.0f*3.14159)

int mousedx,mousedy;

unsigned int vb_name;
unsigned int vbc_name;

float xpos=0,ypos=-300,zpos=0;
float hangle=90.0f,vangle=0;
int mapx=0,mapy=0;

float *terrain_vertexes=NULL;
float *terrain_colors=NULL;

unsigned int *vertex_indexes=NULL;
int offset=0;

bool Initialize();
void CreateWave();
void Render();
void CleanUp();
void UserInput();

int main()
{
bool done=false;
if (!Initialize())
return 0;
while (!done)
{
UserInput();
if (key[KEY_ESC])
done=true;
if (!done)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
Render();
allegro_gl_flip();
}
}
CleanUp();
return 0;
}
END_OF_MAIN();

bool Initialize()
{
allegro_init();
install_allegro_gl();
install_keyboard();
install_mouse();

allegro_gl_set(AGL_Z_DEPTH, 8);
allegro_gl_set(AGL_COLOR_DEPTH, 16);
allegro_gl_set(AGL_SUGGEST, AGL_Z_DEPTH | AGL_COLOR_DEPTH);
const int resx=1024,resy=768;
set_gfx_mode(GFX_OPENGL_FULLSCREEN, resx, resy, 0, 0);
scare_mouse();

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)resx/(GLfloat)resy,1.0f,5000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

glPolygonMode(GL_FRONT,GL_LINE);
glPolygonMode(GL_BACK,GL_LINE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
glShadeModel(GL_SMOOTH);

mapx=64;
mapy=mapx;
terrain_vertexes=(float *)malloc(sizeof(float)*mapx*mapy*3);
terrain_colors=(float *)malloc(sizeof(float)*mapx*mapy*3);
if (!terrain_vertexes||!terrain_colors)
return CLM_FAILED;

HillTerrain my_terrain(mapx,0.0,40.0f,200,1,false,12345);
my_terrain.Generate();//this just generates a terrain of dimensions mapx X mapx
for (int x=0;x<my_terrain.GetSize()*3;x+=3)
{
for (int y=0;y<my_terrain.GetSize();y++)
{
terrain_vertexes[x+y*mapx*3]=(x/3)*(int)MAP_SCALE;
terrain_vertexes[1+x+y*mapx*3]=(float)(my_terrain.GetCell(x/3,y)*MAX_HEIGHT);
terrain_vertexes[2+x+y*mapx*3]=-y*(int)MAP_SCALE;

terrain_colors[0+x+y*mapx*3]=0.0f;
terrain_colors[1+x+y*mapx*3]=(float)(my_terrain.GetCell(x/3,y)*MAX_HEIGHT)/255.0f*COLOR_CHANGE+(1-COLOR_CHANGE);
terrain_colors[2+x+y*mapx*3]=0.0f;
}
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);

unsigned int cur_index=0;
vertex_indexes=(unsigned int *)malloc(sizeof(unsigned int)*2*mapx*(mapy-1));

if (!vertex_indexes)
return CLM_FAILED;

cur_index=0;

for (int y=0;y<mapy-1;y++)
{
vertex_indexes[cur_index++]=y*mapx;
vertex_indexes[cur_index++]=(y+1)*mapx;
for (int x=1;x<mapx;x++)
{
vertex_indexes[cur_index++]=x+y*mapx;
vertex_indexes[cur_index++]=x+(y+1)*mapx;
}
}
glGenBuffersARB( 1, &vb_name );
glBindBufferARB( GL_ARRAY_BUFFER_ARB,vb_name);
glBufferDataARB( GL_ARRAY_BUFFER_ARB, mapx*mapy*sizeof(float)*3, terrain_vertexes, GL_STATIC_DRAW_ARB );
glVertexPointer(3,GL_FLOAT,0,(char*)NULL);

glGenBuffersARB(1,&vbc_name);
glBindBufferARB(GL_ARRAY_BUFFER_ARB,vbc_name);
glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(float)*mapx*mapy*3,terrain_colors,GL_STATIC_DRAW_ARB);
glColorPointer(3,GL_FLOAT,0,(char*)NULL);

return CLM_PASSED;
}

void CreateWave()
{
}

void Render()
{

glRotatef(vangle,1.0f,0.0f,0.0f);
glRotatef(hangle-90.0f,0.0f,1.0f,0.0f);
glTranslatef(xpos,ypos,zpos);

for (int y=0;y<mapy-1;y++)
glDrawElements(GL_TRIANGLE_STRIP,mapx*2,GL_UNSIGNED_INT,(vertex_indexes+y*mapx*2));
}

void CleanUp()
{
unsigned int nBuffers[2] = { mapx*mapy, mapx*mapy };
glDeleteBuffersARB( 2, nBuffers );
free (terrain_vertexes);
free (terrain_colors);
free (vertex_indexes);
remove_keyboard();
remove_mouse();
}

void UserInput()
{
poll_keyboard();
poll_mouse();
get_mouse_mickeys(&mousedx,&mousedy);
hangle+=mousedx;
vangle+=mousedy;
if (hangle>360.0f)
hangle-=360.0f;
if (hangle<=0.0f)
hangle+=360.0f;
if (key[KEY_LEFT]||key[KEY_A])
{
xpos+=MOVEMENT_SIZE*sin(RAD(hangle));
zpos-=MOVEMENT_SIZE*cos(RAD(hangle));
}
if (key[KEY_RIGHT]||key[KEY_D])
{
xpos-=MOVEMENT_SIZE*sin(RAD(hangle));
zpos+=MOVEMENT_SIZE*cos(RAD(hangle));
}
if (key[KEY_UP]||key[KEY_W])
{
xpos+=MOVEMENT_SIZE*cos(RAD(hangle))*cos(RAD(vangle));
zpos+=MOVEMENT_SIZE*sin(RAD(hangle))*cos(RAD(vangle));
ypos+=MOVEMENT_SIZE*sin(RAD(vangle));
}
if (key[KEY_DOWN]||key[KEY_S])
{
xpos-=MOVEMENT_SIZE*cos(RAD(hangle))*cos(RAD(vangle));
zpos-=MOVEMENT_SIZE*sin(RAD(hangle))*cos(RAD(vangle));
ypos-=MOVEMENT_SIZE*sin(RAD(vangle));
}
}
<code>
[/edit]

[edit2]
I change it so that it only used 1 array for the vertices, and just rendered them without colors (so they were all the same shade of white). I get the exact same frame rate though, so it isn't that I'm using two arrays.
[/edit2]

[edit3]
I changed my code so that I know longer use glDrawElements, but instead glDrawArrays. Like nehe's code, some of my strips of triangles go straight across the level when I run it, leaving some holes in my terrain. How do I fix this? And I still didn't get a speed improvement, even if I take out one of the arrays, so that I only draw one array (someone claimed that my driver may not be able to handle two arrays at once). Attach is my new source code.
[/edit3]

It might be that you never call glDisableClientState(GL_VERTEX_ARRAY); Usually what you would do is activate a vertex buffer, draw it and then immediately de-activate it. You're code leaves a single VBO pointer active permanently which may have some unintended consequences. I would try activating, drawing and deactivating the VBO every frame (like the Nehe code) and see if it makes a difference.

That won't help at all - it's perfectly valid, and in fact encouraged, to minimize state changes between primitive calls.

Here's something you may want to try: Use GLubyte for color instead of GLfloat, and see if that helps.

Oh, and:

  unsigned int nBuffers[2] = { mapx*mapy, mapx*mapy };
   glDeleteBuffersARB( 2, nBuffers );

This is not how you use glDeleteBuffers().

Did you using GLubyte for color instead of GLfloat?

Not likely.

Can you try binding a texture and passing texture coordinates too?

Don't do that. Promote vendor-neutral extensions.

Yes, it will be hard (more for VAR than VAO, but VAO replaces all of the gl*Pointer and glDraw* calls), and no, it probably won't be signficantly faster. And if it is, you can rest assured that drivers will improve until it isn't.

To be burutally honest, these are the best drivers ATI has had in a very very long time. Thier apps stil need work though... Stupid Ati Center thing liked to freeze on my computer...

No, his problem is with his code on the Radeon 7500.

Mr. Xboxor: Does NeHe's code run fast on the school's Radeon 7500?

The issue has been resolved - enabling texturing, binding a texture and passing in texture coordiantes works around the speed issue on the Radeon 7500. Someone should probably file a driver bug.

How can you be sure of that if you don't try?

Why? If there are driver irregularities, accept them. Inform ATi of the problem, and be done with it. ATi will either fix the problem, allowing those computers to run decently, or not. You post a warning about it in your ReadMe.txt, and you're done.

When submitting a bug report, you should send them a small test app that demonstraits the problem.

Test app might be a bad idea. They likely delete any email with an attachment or most of them. I also doubt they'll listen to your average consumer's complaint, but I guess it's worth a try.