OpenGL VBO

I've been working on a Mesh class that loads and renders Wavefront Studio OBJ files. And I've gotten it to correctly load the data and seemingly correctly insert it into a VBO. But I can't get it to render correctly. Everytime it calls glDrawArrays(), the window closes and the program crashes.

After a few hours of fiddling around and rewriting it different ways, I thought I'd upload it here and see what stupid thing I'm doing wrong. :(

Code:

---

/*
 * Mesh class
 */
#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "SDL.h"
#include "types.h"

#ifndef __MESH_HEADER__
#define __MESH_HEADER__

class Mesh {
  public:
    Mesh();
    ~Mesh();
   
    int LoadOBJ(const char *filename);
    void Render();
   
  private:
    GLuint bufferID;
    GLuint bufferSize;
    GLuint normalOffset;
    GLuint textureOffset;
};

#endif

---

Code:

---

/*
 * Mesh class
 */
#include <stdio.h>
#include <vector>
#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "SDL.h"
#include "mesh.h"
#include "types.h"
using namespace std;

#define BUFFER_OFFSET(i) (((char *)NULL + (i)))

// Determines the type of face being loaded from an OBJ file
int GetFaceType(const char *buffer) {
  int count = 0;
 
  for (int index = 0; index < strlen(buffer); index++) {
    if (buffer[index] == '/') {
      if (buffer[index + 1] == '/')
        return VERTEX_NORMAL;
      else
        count++;
    }
  }
 
  switch (count) {
    case 3:
      return VERTEX_TEXTURE;
   
    case 6:
      return VERTEX_NORMAL_TEXTURE;
  }
 
  return VERTEX_ONLY;
};

Mesh::Mesh() {
  // Enable vertex arrays
  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_NORMAL_ARRAY);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
};

Mesh::~Mesh() {
  // Delete the VBOs, if needed
  if (bufferID) glDeleteBuffers(1, &bufferID);
};

int Mesh::LoadOBJ(const char *filename) {
  // Create vector buffers to hold vertex, normal, and texture data
  vector <Float3> vertexBuffer;
  vector <Float3> normalBuffer;
  vector <Float3> textureBuffer;
  vector <Face>  faceBuffer;
 
  // Try opening the desired file
  FILE *OBJFile = fopen(filename, "r");
  if (!OBJFile) {
    fprintf(stderr, "[MESH] Unable to load mesh named %s.\n", filename);
    return 1;
  }
 
  // Read in the object file
  char  buffer[255];
  int    facetype;
  Float3 tempFloat;
  Face  tempFace;
 
  while (fgets(buffer, 255, OBJFile) != NULL) {
    switch (buffer[0]) {
      case 'v':
        switch (buffer[1]) {
          case 'n': // Vertex normal
            sscanf(buffer, "vn  %f %f %f", &tempFloat.X, &tempFloat.Y, &tempFloat.Z);
            normalBuffer.push_back(tempFloat);
            break;
          case 't': // Vertex texture
            sscanf(buffer, "vt  %f %f %f", &tempFloat.X, &tempFloat.Y, &tempFloat.Z);
            textureBuffer.push_back(tempFloat);
            break;
          default: // Vertex
            sscanf(buffer, "v  %f %f %f", &tempFloat.X, &tempFloat.Y, &tempFloat.Z);
            vertexBuffer.push_back(tempFloat);
            break;
        }
        break;
     
      case 'f': // Face
        facetype = GetFaceType(buffer);
        switch (facetype) {
          case VERTEX_ONLY:
            sscanf(buffer, "f %d %d %d", &tempFace.Vertex.X, &tempFace.Vertex.Y, &tempFace.Vertex.Z);
            tempFace.FaceType = facetype;
            faceBuffer.push_back(tempFace);
            break;
         
          case VERTEX_NORMAL:
            sscanf(buffer, "f %d//%d %d//%d %d//%d", &tempFace.Vertex.X, &tempFace.Normal.X,
                                                    &tempFace.Vertex.Y, &tempFace.Normal.Y,
                                                    &tempFace.Vertex.Z, &tempFace.Normal.Z);
            tempFace.FaceType = facetype;
            faceBuffer.push_back(tempFace);
            break;
         
          case VERTEX_TEXTURE:
            sscanf(buffer, "f %d/%d %d/%d %d/%d", &tempFace.Vertex.X, &tempFace.Texture.X,
                                                  &tempFace.Vertex.Y, &tempFace.Texture.Y,
                                                  &tempFace.Vertex.Z, &tempFace.Texture.Z);
            tempFace.FaceType = facetype;
            faceBuffer.push_back(tempFace);
            break;
         
          case VERTEX_NORMAL_TEXTURE:
            sscanf(buffer, "f %d/%d/%d %d/%d/%d %d/%d/%d", &tempFace.Vertex.X, &tempFace.Texture.X, &tempFace.Normal.X,
                                                          &tempFace.Vertex.Y, &tempFace.Texture.Y, &tempFace.Normal.Y,
                                                          &tempFace.Vertex.Z, &tempFace.Texture.Z, &tempFace.Normal.Z);
            tempFace.FaceType = facetype;
            faceBuffer.push_back(tempFace);
            break;
         
          default:
            break;
        }
        break;
     
      default:
        break;
    }
  }
 
  // Close the file
  fclose(OBJFile);
 
  // Process the data into arrays
  GLuint  vertexArraySize = 0;
  GLuint  normalArraySize = 0;
  GLuint  textureArraySize = 0;
  GLfloat vertexArray[faceBuffer.size() * 3];
  GLfloat normalArray[faceBuffer.size() * 3];
  GLfloat textureArray[faceBuffer.size() * 3];
 
  for (int index = 0; index < faceBuffer.size(); index++) {
    vertexArray[index]    = faceBuffer.at(index).Vertex.X;
    vertexArray[index + 1] = faceBuffer.at(index).Vertex.Y;
    vertexArray[index + 2] = faceBuffer.at(index).Vertex.Z;
    vertexArraySize++;
   
    switch (faceBuffer.at(index).FaceType) {
      case VERTEX_NORMAL:
        normalArray[index]    = faceBuffer.at(index).Normal.X;
        normalArray[index + 1] = faceBuffer.at(index).Normal.Y;
        normalArray[index + 2] = faceBuffer.at(index).Normal.Z;
        normalArraySize++;
        break;
     
      case VERTEX_TEXTURE:
        textureArray[index]    = faceBuffer.at(index).Texture.X;
        textureArray[index + 1] = faceBuffer.at(index).Texture.Y;
        textureArray[index + 2] = faceBuffer.at(index).Texture.Z;
        textureArraySize++;
        break;
     
      case VERTEX_NORMAL_TEXTURE:
        normalArray[index]      = faceBuffer.at(index).Normal.X;
        normalArray[index + 1]  = faceBuffer.at(index).Normal.Y;
        normalArray[index + 2]  = faceBuffer.at(index).Normal.Z;
        textureArray[index]    = faceBuffer.at(index).Texture.X;
        textureArray[index + 1] = faceBuffer.at(index).Texture.Y;
        textureArray[index + 2] = faceBuffer.at(index).Texture.Z;
        normalArraySize++;
        textureArraySize++;
        break;
    }
  }
 
  bufferSize    = faceBuffer.size();
  normalOffset  = vertexArraySize;
  textureOffset = vertexArraySize + normalArraySize;
 
  // Generate and feed the data into the VBO
  glGenBuffers(1, &bufferID);
  glBindBuffer(GL_ARRAY_BUFFER, bufferID);
  glBufferData(GL_ARRAY_BUFFER, bufferSize * sizeof(GLfloat) * 3, NULL, GL_STATIC_DRAW);
 
  glBufferSubData(GL_ARRAY_BUFFER, 0, vertexArraySize * sizeof(GLfloat), vertexArray);
  glBufferSubData(GL_ARRAY_BUFFER, normalOffset, normalArraySize * sizeof(GLfloat), normalArray);
  glBufferSubData(GL_ARRAY_BUFFER, textureOffset, textureArraySize * sizeof(GLfloat), textureArray);
};

void Mesh::Render() {
  // Render the contents of the VBO
  glBindBufferARB(GL_ARRAY_BUFFER, bufferID);
    glVertexPointer(3, GL_FLOAT, 0, 0);
    glNormalPointer(GL_FLOAT, normalOffset, 0);
    glTexCoordPointer(3, GL_FLOAT, textureOffset, 0);
  glDrawArrays(GL_TRIANGLES, 0, bufferSize);
};

---

Vertex arrays and VBO's seem to be my bane as well, sorry I can't provide much help.

But the problem you've described sounds like your accessing a null pointer, make sure in debug mode you're filling your VBO's properly and whatnot.

Yeah that sounds like the culprit. Its code like this that really makes me want to purchase a premade engine. :p

Tell me about it, 3d programming is rough.

I think I'm going to rewrite what little my engine consists of from scratch - have the mesh class consist of just the parts that handle storing, rendering, and maybe animating of meshes. Then spread out other functions to other classes. Like a MeshLoader class. :p

To handle your loading try a resource manager, I can help you in creating one if you wish, and I'm sure Bubba will throw in his ideas as well, two different ideas but both perfectly valid.