Problems with perspective in Open_GL - c++

Question

Could someone please explain me what is wrong in my code? When I try to run it I get a black window, but if I don't set the perspective matrix as I do in the 31th line I get the right solid (a pyramid) drawn on the window. Here's the main of the code. In the vertex shader I just define model, view and projection as uniform 4x4 matrices and multiply them by the poistion of the vertex and pass the colors of the vertices to the fragment shader. I don't think the problem is in those files but if you need them I'll post them.
#include <iostream>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include <string>
#include <fstream>
#include <sstream>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
using namespace std;
GLuint IBO, VBO, gModelLocation, gViewLocation, gProjectionLocation;
#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
const char* VSfileName = "vertex.vs";
const char* FSfileName = "fragment.fs";
void RenderSceneCB()
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glm::mat4 model;
model = glm::rotate( model, 0.0f, glm::normalize( glm::vec3( 1.0, 0.0, 0.0 ) ) );
glm::mat4 view;
view = glm::translate( view, glm::vec3( 0.0f, 0.0f, 0.0f ) );
glm::mat4 projection;
projection = glm::perspective( 90.0f, float( WINDOW_WIDTH ) / float( WINDOW_HEIGHT ), 0.1f, 100.0f );
glUniformMatrix4fv( gModelLocation, 1, GL_FALSE, &model[ 0 ][ 0 ] );
glUniformMatrix4fv( gViewLocation, 1, GL_FALSE, &view[ 0 ][ 0 ] );
glUniformMatrix4fv( gProjectionLocation, 1, GL_FALSE, glm::value_ptr( projection ) );
glBindBuffer( GL_ARRAY_BUFFER, VBO );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, IBO );
glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray( 0 );
glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)( 15 * sizeof( GLfloat ) ) );
glEnableVertexAttribArray( 1 );
glDrawElements( GL_TRIANGLES, 12, GL_UNSIGNED_INT, 0 );
//glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableVertexAttribArray( 1 );
glDisableVertexAttribArray( 0 );
glutSwapBuffers();
}
void InizializeGlutCallBacks()
{
glutDisplayFunc( RenderSceneCB );
glutIdleFunc( RenderSceneCB );
}
void InizializeVertices()
{
GLfloat Vertices[ 9 ][ 3 ]
{
{ -0.5f, 0.5f, 0.0f},
{ 0.5f, -0.5f, 0.0f },
{ 0.5f, 0.5f, 0.0f},
{ -0.5f, -0.5f, 0.0f },
{ 0.0f, 0.0f, 1.0f},
{ 1.0f, 0.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f },
{ 1.0f, 1.0f, 1.0f}
};
GLint Indices[ 12 ]
{
0,2,4,0,3,4,1,2,4,1,3,4
};
glGenBuffers( 1, &VBO );
glGenBuffers( 1, &IBO );
glBindBuffer( GL_ARRAY_BUFFER, VBO );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, IBO );
glBufferData( GL_ARRAY_BUFFER, sizeof( Vertices ), Vertices, GL_STATIC_DRAW );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( Indices ), Indices, GL_STATIC_DRAW );
}
void AddShader( GLuint ShaderProgram, const char* ShaderSource, GLenum ShaderType )
{
GLuint ShaderObj = glCreateShader( ShaderType );
if( ShaderObj == 0 )
{
fprintf( stderr, "Error creating Shader Object %d \n", ShaderType );
}
const GLchar* p[ 1 ];
p[ 0 ] = ShaderSource;
GLint Lengths[ 1 ];
Lengths[ 0 ] = strlen( p[ 0 ] );
glShaderSource( ShaderObj, 1, p, Lengths );
glCompileShader( ShaderObj );
GLint success;
glGetShaderiv( ShaderObj, GL_COMPILE_STATUS, &success );
if( !success )
{
GLchar InfoLog[ 1024 ];
glGetShaderInfoLog( ShaderObj, 1024, NULL, InfoLog );
fprintf( stderr, "Error Compiling Shader %d: '%s' \n", ShaderType, InfoLog );
}
glAttachShader( ShaderProgram, ShaderObj );
}
void CompileShaders()
{
GLuint ShaderProgram = glCreateProgram();
if( ShaderProgram == 0 )
{
fprintf( stderr, "Error creating Shader Program \n" );
}
string vs, fs;
ifstream VertexFile;
ifstream FragmentFile;
VertexFile.open( VSfileName );
if( !VertexFile )
{
std::cout << "Error in opening vertex.vs \n";
exit( 1 );
}
FragmentFile.open( FSfileName );
if( !FragmentFile )
{
std::cout << "Error in opening fragment.fs \n";
exit( 1 );
}
stringstream VertexStream;
stringstream FragmentStream;
VertexStream << VertexFile.rdbuf();
FragmentStream << FragmentFile.rdbuf();
vs = VertexStream.str();
fs = FragmentStream.str();
AddShader( ShaderProgram, vs.c_str(), GL_VERTEX_SHADER );
AddShader( ShaderProgram, fs.c_str(), GL_FRAGMENT_SHADER );
glLinkProgram( ShaderProgram );
GLint success;
glGetProgramiv( ShaderProgram, GL_LINK_STATUS, &success );
if( !success )
{
GLchar InfoLog[ 1024 ];
glGetProgramInfoLog( ShaderProgram, 1024, NULL, InfoLog );
fprintf( stderr, "Error in linking Shader '%s' \n", InfoLog );
}
glValidateProgram( ShaderProgram );
glGetProgramiv( ShaderProgram, GL_VALIDATE_STATUS, &success );
if( !success )
{
GLchar InfoLog[ 1024 ];
glGetProgramInfoLog( ShaderProgram, 1024, NULL, InfoLog );
fprintf( stderr, "Error in linking Shader '%s' \n", InfoLog );
}
//gScaleLocation = glGetUniformLocation(ShaderProgram, "gScale");
gModelLocation = glGetUniformLocation( ShaderProgram, "gModel" );
gViewLocation = glGetUniformLocation( ShaderProgram, "gView" );
gProjectionLocation = glGetUniformLocation( ShaderProgram, "gProjection" );
glUseProgram( ShaderProgram );
}
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( WINDOW_WIDTH, WINDOW_HEIGHT );
glutInitWindowPosition( 100, 100 );
glutCreateWindow( "Hello World" );
InizializeGlutCallBacks();
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
GLenum res = glewInit();
if( res != GLEW_OK )
{
std::cout << "Error, check please \n";
}
glViewport( 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT );
glEnable( GL_DEPTH_TEST );
// enable alpha support
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
InizializeVertices();
CompileShaders();
glutMainLoop();
system( "pause" );
return 0;
}

Answer 1

First of all you should initialize all the matrizes (see glm returning nan on simple translate):
glm::mat4 model(1.0f);
glm::mat4 view(1.0f);
glm::mat4 projection(1.0f);
The geometry has to be in the clip space. When you setup the projection, then you define a near plan of 0.1 and a far plane of 100.0. This both values define the near and the far clipping plane.
This means you can only "see" the geomentry with a Z-component in the range [0.1, 100.0].
Setup the view matrix, to solve your issue.
glm::mat4 view(1.0f);
view = glm::translate( view, glm::vec3( 0.0f, 0.0f, -1.0f ) );
Further:
See the GLM documentation of glm::perspective, version 0.9.8:
LM_FUNC_DECL tmat4x4<T, defaultp> glm::perspective(T fovy, T aspect, T near, T far)
Creates a matrix for a symetric perspective-view frustum based on the default handedness.
Parameters
fovy Specifies the field of view angle in the y direction. Expressed in radians.
At the same place is noted for the version 0.9.4 (glm::perspective, version 0.9.4):
fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
This is because the GLM in general changed from degrees to radians a while ago.
Setup the perspective projection matrix like this:
projection = glm::perspective(
90.0f * (float)M_PI / 180.0,
float( WINDOW_WIDTH ) / float( WINDOW_HEIGHT ),
0.1f, 100.0f );
Explanation:
The view matrix describes the direction and position from which the scene is looked at. The view matrix transforms from the wolrd space to the view (eye) space.
The projection matrix describes the mapping from 3D points of a scene, to 2D points of the viewport. It transforms from eye space to the clip space, and the coordinates in the clip space are transformed to the normalized device coordinates (NDC) by dividing with the w component of the clip coordinates. The NDC are in range (-1,-1,-1) to (1,1,1). Every geometry which is out of the clippspace is clipped.
At Perspective Projection the projection matrix describes the mapping from 3D points in the world as they are seen from of a pinhole camera, to 2D points of the viewport. The eye space coordinates in the camera frustum (a truncated pyramid) are mapped to a cube (the normalized device coordinates).