I've had working VBOs for a while now. And Now im trying to load a terrain into and array of heights and then load them into my vertex structure to be rendered from the VBO, however when i run the code in immediate mode, it looks good and when its through the VBO. All the points don't connect.
In immediate mode this is the code
for (int i = 0; i < terrainGridLength - 1; i++)
{
glBegin(GL_TRIANGLE_STRIP);
for (int j = 0; j < terrainGridWidth; j++)
{
glVertex3f(startW + j + xOffset, mHeights[(i + 1)
* terrainGridWidth + (j)] + yOffset, startL - (i + 1)
+ zOffset);
//Now lets copy the terrain data into our vertex structure so we can render;
for (int i = 0, marker = 0; i < mWidth; i++)
{
for (int j = 0; j < mHeight; j++, marker++)
{
mVBO->Bind();
// Set the state of what we are drawing (I don't think order matters here, but I like to do it in the same
// order I set the pointers
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
// Resetup our pointers. This doesn't reinitialise any data, only how we walk through it
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), BUFFER_OFFSET(12));
glNormalPointer(GL_FLOAT, sizeof(Vertex), BUFFER_OFFSET(20));
glColorPointer(4, GL_FLOAT, sizeof(Vertex), BUFFER_OFFSET(32));
glVertexPointer(3, GL_FLOAT, sizeof(Vertex), BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLE_STRIP, 0, mTerrainSize);
// Disable our client state back to normal drawing
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
//original
for (int i = 0; i < terrainGridLength - 1; i++)
{
glBegin(GL_TRIANGLE_STRIP);
for (int j = 0; j < terrainGridWidth; j++)
{
[...]
[/quote]
The vbo isnt doing that. Notice that you do a strip per part of the terrain. the vbo does this as if you had this with immediate mode:
//this is what's happening when you draw using the vbo (in terms of immediate)
glBegin(GL_TRIANGLE_STRIP);
for (int i = 0; i < terrainGridLength - 1; i++)
{
for (int j = 0; j < terrainGridWidth; j++)
{
[...]
}
}
[/quote]
which will attempt to connect all the points regardless of vertex position.
I know nvidia has an extension that has a way to address this but I'm not sure about amd. Other than that you can switch to using GL_TRIANGLES instead or use glDrawArraysRange.
No that's not the problem as I just tried compiling that. It give the same results. I've determined that it has to do with how im putting the vertices into my structure. Im missing something muy importante that is causing it to be choppy.
What I posted wasn't going to solve the problem. It was just showing what your vbo is doing in terms of immediate mode. I can only think to use primitive restart (which I think is ext only from nvidia I haven't used it) or use triangles instead. I personally use triangles with an element array list for my terrain.
What I posted wasn't going to solve the problem. It was just showing what your vbo is doing in terms of immediate mode.
Well even if that was what it was doing, It wouldn't make a difference. I tried rendering what you said in immediate mode (what you said my VBO was doing) and I still got the same working results. Thats what pointed me to my vertices being wrong somehow.
And I looked into the indices but was unsure how to generate them only from a heightmap
when iterating the marker it should be marker+=2.
You write over previous vertices positions with marker++.
at the very least it should show better.
still this:
glBegin(GL_TRIANGLE_STRIP);
for (int i = 0; i < terrainGridLength - 1; i++)
{
for (int j = 0; j < terrainGridWidth; j++)
{
[...]
}
}
glEnd();
[/quote]
which looks correct at first (from you testing it) but really looks like this: (you can check it with glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); )
(if the terrain was flat)
try this out:
terrainGridLength = 10
terrainGridWidth = 20
for (int i = 0, marker = 0; i < terrainGridLength; i++)
{
for (int j = 0; j < terrainGridWidth/2; j++, marker+=2)
{
mVertexData[marker].positions[0] = startW + j + xOffset;
mVertexData[marker].positions[1] = startL - (i + 1 + k) + zOffset;
mVertexData[marker].positions[2] = 0.0f;
mVertexData[marker + 1].positions[0] = startW + j + xOffset;
mVertexData[marker + 1].positions[1] = startL - i - k + zOffset;
mVertexData[marker + 1].positions[2] = 0.0f;
}
}
[/quote]
I get the same thing above
Yes i thought that about the marker++ but when I tried marker += 2 it crashed and i attributed that to the fact the i would be writing outside of the allocated bounds of memory in the vertex data.
SO should I allocate more space in the VertexData?
Yes i thought that about the marker++ but when I tried marker += 2 it crashed and i attributed that to the fact the i would be writing outside of the allocated bounds of memory in the vertex data.
SO should I allocate more space in the VertexData?
did you terrainGridWidth/2. it would go out of range without this.
for (int i = 0, marker = 0; i < terrainGridLength; i++)
{
for (int j = 0; j < terrainGridWidth/2; j++, marker+=2)
{
[...][/quote]
