[OpenGL] Esercizio per disegnare un cubo mostra solo la faccia frontale

[-Ivan-]

Sto facendo un esercizio in cui cerco di disegnare un cubo con OpenGL.
Non riesco a capire perchè mi mostri solo la faccia frontale.
Per disegnarlo uso glDrawElements dopo aver creato un buffer di indici ed il buffer con i vertici del cubo.



// include...


enum Attrib_IDs { vPosition = 0 };

GLuint VERTEX_SHADER_ID;

GLuint VBOs[1]; // Vertex Buffer Objects
GLuint IBOs[1]; // Index Buffer Objects

GLuint SCREEN_WIDTH = 512, SCREEN_HEIGHT = 512;

glm::mat4 mvp; //model view projection matrix



#pragma region INITIALIZE DATA AND OPENGL

void ModelViewProjectionMatrix()
{
// Matrix to translate the cube deep far in the scene
glm::mat4 model = glm::translate(glm::mat4(1.0f), glm::vec3(0.0, 0.0, -4.0));

// The lookat function takes: eye (position of the camera), center (where the camera is pointed to), and up (top of the camera).
glm::mat4 view = glm::lookAt(glm::vec3(0.0, 2.0, 0.0), glm::vec3(0.0, 0.0, -4.0), glm::vec3(0.0, 1.0, 0.0));

// The perpective function takes: fovy (the lens angle), aspect (the aspect ratio), and zNear, zFar (clipping planes).
glm::mat4 projection = glm::perspective(45.0f, 1.0f * SCREEN_WIDTH/SCREEN_HEIGHT, 0.1f, 10.0f);


// We end up with a model view projection matrix giving us the result for our camera
mvp = projection * view * model;
}

void CreateVerticesData()
{
Vector3D cube_vertices[] = {
// front
Vector3D(-1.0, -1.0, 1.0),
Vector3D( 1.0, -1.0, 1.0),
Vector3D( 1.0, 1.0, 1.0),
Vector3D(-1.0, 1.0, 1.0),
// back
Vector3D(-1.0, -1.0, -1.0),
Vector3D( 1.0, -1.0, -1.0),
Vector3D( 1.0, 1.0, -1.0),
Vector3D(-1.0, 1.0, -1.0)
};

// Generate the Vertex Buffer Object storing the data for the 8 vertices of the cube.
// In total there are 24 floats representing the x, y, z components of each vertex.
glGenBuffers(1, VBOs);
glBindBuffer(GL_ARRAY_BUFFER, VBOs[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
}

void CreateIndexData()
{
// Indices of the vertices of the cube.
// This is used to avoid duplicates. As the faces of the cube share vertices we can duplicate this vertices ending with a
// total of 36 (6 faces x 2 triangles per face x 3 vertices each triangle = 36) or we can store them just once and refer to them
// using these indices and drawing the cube with glDrawElements instead than with glDrawArray that just iterates through an array
// drawing every vertices it finds in it.
GLushort cube_elements[] = {
// front
0, 1, 2,
2, 3, 0,
// top
3, 2, 6,
6, 7, 3,
// back
7, 6, 5,
5, 4, 7,
// bottom
4, 5, 1,
1, 0, 4,
// left
4, 0, 3,
3, 7, 4,
// right
1, 5, 6,
6, 2, 1,
};

// Generate the Index Buffer Object to index the vertices inside the Vertex Buffer Object.
// The indexes are related to the 8 vertices making the cube.
glGenBuffers(1, IBOs);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBOs[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_elements), cube_elements, GL_STATIC_DRAW);
}

void Init()
{
glEnable(GL_DEPTH_TEST);
ModelViewProjectionMatrix();

CreateVerticesData();
CreateIndexData();

// Load and use the shaders
VERTEX_SHADER_ID = LoadShader("shader.vert", "shader.frag");
glUseProgram(VERTEX_SHADER_ID);

// Set up the value of the uniform value inside the vertex shader
GLuint mvp_Loc = glGetUniformLocation(VERTEX_SHADER_ID, "mvp");
glUniformMatrix4fv(mvp_Loc, 1, GL_FALSE, glm::value_ptr(mvp));

// Defines parameters to pass to the shaders
glVertexAttribPointer(vPosition, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glEnableVertexAttribArray(vPosition);
}

#pragma endregion

void Display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

int size;
glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBOs[0]);
glDrawElements(GL_TRIANGLES, size / sizeof(GLushort), GL_UNSIGNED_SHORT, 0);

// marks the current window as needing to be redisplayed
glutPostRedisplay();
glFlush();
}

int _tmain(int argc, _TCHAR* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA);
glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);
glutInitContextVersion(3, 3);
glutInitContextProfile(GLUT_CORE_PROFILE);
glutCreateWindow("Cube");

if( glewInit() )
{
std::cerr << "Error...exiting";
exit(EXIT_FAILURE);
}

Init();

glutDisplayFunc(Display);
glutMainLoop();

return 0;
}

[-Ivan-]

Ho trovato.
L'errore era in:

glVertexAttribPointer(vPosition, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));


che invece deve essere:


glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));


Stavo ignorando l'asse Z. Purtroppo avevo copiato quella riga da un altro esercizio in cui disegnavo un triangolo e quindi avevo coordinate su due dimensioni.