Render OpenGL object in a class? - c++

Question

I'm trying to learn modern OpenGL and create classes for various primitive types such as cubes, spheres, etc. I have run into a problem, though, where my cube class isn't rendering anything in its Draw() function, but if I move it all into my main() function it works fine.
Here's the code for cube.cpp:
#include "cube.h"
#include <iostream>
GLuint Cube::indexArr[36] = {
0, 1, 2, // front face
2, 3, 1,
4, 5, 6,
6, 7, 4,
7, 3, 0,
0, 4, 7,
6, 2, 1,
1, 5, 6,
0, 1, 5,
5, 4, 0,
3, 2, 6,
6, 7, 3
};
bool Cube::cubeSetUp = false;
GLuint Cube::cubeVBO = 0;
GLuint Cube::cubeVAO = 0;
GLuint Cube::cubeEBO = 0;
Cube::Cube()
{
if (!cubeSetUp)
SetUpCube();
//define the 8 vertices that make up a cube
objectVerts = new GLfloat[24] {
-0.5f, -0.5f, -0.5f, // front bottom left 0
0.5f, -0.5f, -0.5f, // front bottom right 1
0.5f, 0.5f, -0.5f, // front top right 2
-0.5f, 0.5f, -0.5f, // front top left 3
-0.5f, -0.5f, 0.5f, // back bottom left 4
0.5f, -0.5f, 0.5f, // back bottom right 5
0.5f, 0.5f, 0.5f, // back top right 6
-0.5f, 0.5f, 0.5f // back top left 7
};
}
void Cube::Draw()
{
glBindVertexArray(cubeVAO);
//GLfloat modelMatrix[16];
//transform.affine.ConvertToOpenGLMatrix(modelMatrix);
//glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, modelMatrix);
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
}
void Cube::SetUpCube()
{
cubeSetUp = true;
glGenVertexArrays(1, &cubeVAO);
glGenBuffers(1, &cubeVBO);
glGenBuffers(1, &cubeEBO);
glBindVertexArray(cubeVAO);
glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(objectVerts), objectVerts, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cubeEBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indexArr), indexArr, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
Code for cube.h:
#ifndef __CUBE__H_
#define __CUBE__H_
#include "scene_object.h"
class Cube : public SceneObject
{
public:
/***************
* Constructor *
***************/
Cube();
/***********************
* Overloaded Function *
***********************/
void Draw();
private:
static GLuint indexArr[36];
static bool cubeSetUp;
static GLuint cubeVBO, cubeVAO, cubeEBO;
void SetUpCube();
};
#endif
Am I doing something wrong? Does OpenGL not agree with using a static array for my index array? I tried getting rid of the element buffer object and just using glDrawArrays(...), but it also didn't work. I can provide the code for the main as well, if needed.
Also, the vertex shader isn't doing anything. It just receives the vertex information and gives it to gl_Position.
Thanks for any help.
Code for main.cpp:
#define GLEW_STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <fstream>
#include <string>
#include "shader.h"
#include "cube.h"
#include "camera.h"
using namespace std;
int main(int argc, char* argv[])
{
if (argc != 3)
{
cout << "Incorrect number of arguments!" << endl;
cout << "Usage: [executable] vertexShader fragmentShader" << endl;
return -1;
}
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow* window = glfwCreateWindow(800, 600, "Scene Description Language Generator", nullptr, nullptr);
if (window == nullptr)
{
std::cout << "Failed to create the GLFW window" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK)
{
std::cout << "Failed to initialize GLEW" << std::endl;
return -1;
}
glEnable(GL_DEPTH_TEST);
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
Shader shader(argv[1], argv[2]);
Cube c;
GLuint modelMat = glGetUniformLocation(shader.GetProgram(), "model");
c.SetModelMatrixLoc(modelMat);
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
glClearColor(0.2f, 0.3f, 0.3f, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shader.Use();
c.Draw();
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
Edits: Added code for main.cpp and cube.h in case it is valuable to see.

Answer 1

At least two things going wrong.
First, as pointed out by pleluron, the cube constructor gets called before the application window and GL context has been created. On older systems this would usually crash. On modern computers there is probably a default GL context created by the windowing system, so the cube gets created for that. Then your application creates its own window and context and the cube is orphaned.
Creating OpenGL "objects" should only happen in a designated method, called only when it is safe to do so. In Qt it's the view setupGL method, in MacOS Cocoa it's prepareOpenGL, other systems it's the first window draw.
Second problem, as pointed out by BDL, is that sizeof(objectVerts) does not do what you think it does. A print statement will show you.
Third problem is that you're not calling glGetError(). OpenGL does not throw exceptions when you do something wrong, and often doesn't crash. Instead it just does nothing. Develop the habit of calling glGetError() at the end of each important function or method just to be sure everything is OK. If errors do happen, put more glGetErrors() in to narrow down the cause.