Буферы вершин и проблемы рендеринга

Я пытаюсь приблизить изогнутую поверхность, используя четырехугольные пятна. Я сделал это, используя прямой рендеринг, используя GL_QUADS и указав четыре вершины четырехугольного патча.

Теперь я пытаюсь добиться некоторой производительности, используя буферы вершин и наложенный массив (verNor) вершин и нормалей. Проблема в том, что я получаю некоторые случайные формы, но не ту, которую я получил ранее.

Здесь я помещаю свой код:

      GLenum err = glewInit();
if (GLEW_OK != err){
std::cout<<"Filed to Initialize GLEW :: "<<glewGetErrorString(err)<<std::endl;
}

verNor = new GLfloat [NA*NP*6];   // NA and NP are number of points in lets say x and y axis
indices = new GLuint [(NA)*(NP)*4];   // When the tube is cut an spread out.// VBOs
glGenBuffers(1, &vbo_tube); // Ask the GPU driver for a buffer array. "vbo" now has the ID
glGenBuffers(1, &ibo_indices);

// For Vertices and Normals which are interleved
glBindBuffer(GL_ARRAY_BUFFER, vbo_tube);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6*NA*NP, NULL, GL_STATIC_DRAW);
// Obtaining the pointer to the memory in graphics buffer
buffer_verNor = glMapBuffer(GL_ARRAY_BUFFER,GL_WRITE_ONLY);

// For Indices
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_indices);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int) * 4*(NA-1)*(NP-1), NULL, GL_STATIC_DRAW);
buffer_indices = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER,GL_WRITE_ONLY);

// Calculate the vertices of the points around the tube. Correctness guarenteed because I can draw exactly what I wanted
// using normal stright forward GL_QUADS that is drawing quad by quad and with out any VBOs
// Calculated vertices are stored in vPoints.for (int i=0; i<NP; i++) {
for (int j=0; j<NA; j++) {// Calculate the normals of each and every point above and store them in v3

// Storing the vertices
verNor[6*( (i)*NA+(j) )+0] = (GLfloat)vPoints[i*NA+j].GetX();
verNor[6*( (i)*NA+(j) )+1] = (GLfloat)vPoints[i*NA+j].GetY();
verNor[6*( (i)*NA+(j) )+2] = (GLfloat)vPoints[i*NA+j].GetZ();
// Storing the Normals
verNor[6*((i-1)*NA+(j-1))+3] = (GLfloat)v3.GetX();
verNor[6*((i-1)*NA+(j-1))+4] = (GLfloat)v3.GetY();
verNor[6*((i-1)*NA+(j-1))+5] = (GLfloat)v3.GetZ();

// Calculating the indices which form the quad
indices[4*((i)*NA+(j))+0]   =   (GLuint) (i)*NA+j     ;
indices[4*((i)*NA+(j))+1]   =   (GLuint) (i+1)*NA+j   ;
indices[4*((i)*NA+(j))+2]   =   (GLuint) (i+1)*NA+j+1 ;
indices[4*((i)*NA+(j))+3]   =   (GLuint) (i)*NA+j+1   ;
}
}memcpy(buffer_verNor, verNor, 6*(NA)*(NP));
glUnmapBuffer(GL_ARRAY_BUFFER);     // Unmapping the buffer

memcpy(buffer_indices, indices, 4*(NA-1)*(NP-1));
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);glEnable(GL_LIGHTING);
// Performing the Vertex Buffer Stuff
// For Vertices and Normals
glBindBuffer(GL_ARRAY_BUFFER, vbo_tube);
glVertexPointer( 3, GL_FLOAT, 6*sizeof(GLfloat), (GLvoid*)((char*)NULL + 0*sizeof(GLfloat)) );
glNormalPointer( GL_FLOAT, 6*sizeof(GLfloat), (GLvoid*)(((char*)NULL)+3*sizeof(GLfloat)) );

// For Indices
// Mapping the indices_vbo memory here
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_indices);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*4*(NA-1)*(NP-1), indices, GL_STATIC_DRAW);

// Enabling all the buffers and drawing the quad patches
glBindBuffer(GL_ARRAY_BUFFER, vbo_tube);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_indices);

// Enabling normals and vertices to draw
glEnableClientState (GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);

// Drawing the patches
glDrawElements(GL_QUADS, (NA-1)*(NP-1), GL_UNSIGNED_INT,(GLvoid*)((char*)NULL));
// Disabling the buffer objects for safety
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);

glDeleteBuffers(1, &vbo_tube);
glDeleteBuffers(1, &ibo_indices);

У птицы есть NA по NP точкам, поэтому я должен нарисовать (NP-1) * (NA-1) четырехугольников.
Кроме того, я могу рисовать только некоторые вещи (но не правильно), только когда я даю неправильные смещения и шагаю в функциях glVertexPointer () и glNormalPointer (). Правильные, я думаю,
vertexPointer :: Stride — 6 * sizeof (GLfloat), смещение — 0 (последний аргумент)
normalPointer :: Stride — 6 * sizeof (GLfloat), смещение — 3 * sizeof (GLfloat)