Cube not rendering

Hi there, first I want to point out that I’m a huge begginer in OpenGL actually I’ve started today, but I’ve done a bit in WebGL.
Trying to port, from WebGL a simple program that show a cube and this is the result:

(I know that it may seem a strange way to do this, but I need a port that have to look like my WebGL sample)

// Include standard headers
#include <stdio.h>
#include <stdlib.h>
#include <stack>
#include <iostream>


// Include GLEW
#include <GL/glew.h>

// Include GLFW
#include <GL/glfw.h>

// Include GLM
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
using namespace glm;

#include <common/shader.hpp>

int viewportWidth=1024;
int viewporthHeight=768;


int initWindow(char * nome);
void drawScene();
void initBuffers();
void cleanBuffers();
void initShaders();
void mvMatrixPush();
void mvMatrixPop();
void printMat(glm::mat4  mat);
void setMatrixUniform();

struct programField {
	GLint vertexPositionAttribute;
	GLint vertexColorAttribute;
	GLint pMatrixUniform;
	GLint mvMatrixUniform;
	
};

struct bufferField{
	int itemSize;
	int numItems;
};

struct programField program;

GLuint programID;
GLuint VertexArrayID;
GLuint vertexbuffer;

int main( void )
{
	initWindow("Test");
	initShaders();
	initBuffers();
	do{	
		drawScene();
	} // Check if the ESC key was pressed or the window was closed
	while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
		   glfwGetWindowParam( GLFW_OPENED ) );
	// Close OpenGL window and terminate GLFW
	glfwTerminate();

	return 0;
}

void initShaders(){
	programID = LoadShaders( "vs.vertexshader", "fs.fragmentshader" );
	glUseProgram(programID);	
	program.vertexPositionAttribute=glGetAttribLocation(programID, "aVertexPosition");
	glEnableVertexAttribArray(program.vertexPositionAttribute);
	program.vertexColorAttribute=glGetAttribLocation(programID, "aVertexColor");
	glEnableVertexAttribArray(program.vertexColorAttribute);
	program.pMatrixUniform=glGetUniformLocation(programID, "uPMatrix");
	program.mvMatrixUniform=glGetUniformLocation(programID, "uMVMatrix");
}

glm::mat4 mvMatrix = glm::mat4(1.0);
glm::mat4 pMatrix = glm::mat4(1.0);
std::stack<glm::mat4> mvMatrixStack;      

void mvMatrixPush(){
	glm::mat4 copy = glm::mat4(1.0);
	copy = mvMatrix;
	mvMatrixStack.push(copy);
}

void mvMatrixPop(){
	if(mvMatrixStack.size()==0){
		printf("Invalid pop");
		return;
	}
	mvMatrix=mvMatrixStack.top();
	mvMatrixStack.pop();
}

void setMatrixUniform(){
	glUniformMatrix4fv(program.pMatrixUniform, 1, GL_FALSE, &pMatrix[0][0]);
	glUniformMatrix4fv(program.mvMatrixUniform, 1, GL_FALSE, &mvMatrix[0][0]);
}

float degToRad(int degrees){
	return degrees*3.14f/180;
}


GLuint vertexPositionBuffer;
struct bufferField vertexPositionField;
GLuint vertexColorBuffer;
struct bufferField vertexColorField;
GLuint vertexIndexBuffer;
struct bufferField vertexIndicesField;

void initBuffers(){

	glGenBuffers(1, &vertexPositionBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, vertexPositionBuffer);

	static const GLfloat vertices[] = { 
//Faccia frontale
	-1.0,-1.0,1.0,
	1.0,-1.0,1.0,
	1.0,1.0,1.0,
	-1.0,1.0,1.0,

	//Faccia retro
	-1.0,-1.0,-1.0,
	-1.0,1.0,-1.0,
	1.0,1.0,-1.0,
	1.0,-1.0,-1.0,

	//Faccia in cima
	-1.0,1.0,-1.0,
	-1.0,2.0,1.0,
	1.0,2.0,1.0,
	1.0,1.0,-1.0,

	//Faccia sotto
    -1.0, -1.0, -1.0,
    1.0, -1.0, -1.0,
    1.0, -1.0,  1.0,
    -1.0, -1.0,  1.0,

    //Faccia destra
    1.0, -1.0, -1.0,
    1.0,  1.0, -1.0,
    1.0,  1.0,  1.0,
    1.0, -1.0,  1.0,

    //Faccia sinistra
	-1.0, -1.0, -1.0,
    -1.0, -1.0,  1.0,
    -1.0,  1.0,  1.0,
    -1.0,  1.0, -1.0

	};


	
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	vertexPositionField.itemSize=3;
	vertexPositionField.numItems=24;

	
	glGenBuffers(1, &vertexColorBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, vertexColorBuffer);

	static const GLfloat colors[]={
	
	//Faccia frontale
	1.0,0.0,0.0,1.0,
	1.0,0.0,0.0,1.0,
	1.0,0.0,0.0,1.0,
	1.0,0.0,0.0,1.0,

	//Retro
	0.0,1.0,0.0,1.0,
	0.0,1.0,0.0,1.0,
	0.0,1.0,0.0,1.0,
	0.0,1.0,0.0,1.0,

	//In cima
	0.0,0.0,1.0,1.0,
	0.0,0.0,1.0,1.0,
	0.0,0.0,1.0,1.0,
	0.0,0.0,1.0,1.0,

	//Faccia sotto
	1.0,1.0,0.0,1.0,
	1.0,1.0,0.0,1.0,
	1.0,1.0,0.0,1.0,
	1.0,1.0,0.0,1.0,

	//Faccia destra
	0.0,1.0,1.0,1.0,
	0.0,1.0,1.0,1.0,
	0.0,1.0,1.0,1.0,
	0.0,1.0,1.0,1.0,

	//Faccio sinistra
	1.0,0.0,1.0,1.0,
	1.0,0.0,1.0,1.0,
	1.0,0.0,1.0,1.0,
	1.0,0.0,1.0,1.0
	};

	glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
	vertexColorField.itemSize=4;
	vertexColorField.numItems=24;

	glGenBuffers(1, &vertexIndexBuffer);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);

	static const GLint indices[]={
	0,1,2,	0,2,3,
	4,5,6,	4,6,7,
	8,9,10,	8,10,11,
	12,13,14,	12,14,15,
	16,17,18,	16,18,19,
	20,21,22,	20,22,23
	};

	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
	vertexIndicesField.itemSize=1;
	vertexIndicesField.numItems=36;
}



void drawScene(){

		// Clear the screen
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	//	pMatrix=glm::perspective(45.0f, float(viewportWidth/viewporthHeight), 0.1f, 100.0f);

		mvMatrix = glm::mat4(1.0);
		mvMatrix=glm::translate(mvMatrix, glm::vec3(-1.5f,0.0f,-8.0f));

		mvMatrixPush();

		glBindBuffer(GL_ARRAY_BUFFER, vertexPositionBuffer);
		glVertexAttribPointer(
			program.vertexPositionAttribute,                
			vertexPositionField.itemSize,                  // size
			GL_FLOAT,           // type
			GL_FALSE,           // normalized?
			0,                  // stride
			(void*)0            // array buffer offset
		);

		
		glBindBuffer(GL_ARRAY_BUFFER, vertexColorBuffer);
		glVertexAttribPointer(
			program.vertexColorAttribute,                 
			vertexColorField.itemSize,                  // size
			GL_FLOAT,           // type
			GL_FALSE,           // normalized?
			0,                  // stride
			(void*)0            // array buffer offset
		);


		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);
		setMatrixUniform();

	
		glDrawElements(GL_TRIANGLES, vertexIndicesField.numItems, GL_UNSIGNED_SHORT, 0);


		// Swap buffers
		glfwSwapBuffers();

}

int initWindow(char * nome){
	// Initialise GLFW
	if( !glfwInit() )
	{
		fprintf( stderr, "Failed to initialize GLFW
" );
		return -1;
	}

	glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	// Open a window and create its OpenGL context
	if( !glfwOpenWindow( viewportWidth, viewporthHeight, 0,0,0,0, 32,0, GLFW_WINDOW ) )
	{
		fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.
" );
		glfwTerminate();
		return -1;
	}

	glfwSetWindowTitle(nome );

	// Ensure we can capture the escape key being pressed below
	glfwEnable( GLFW_STICKY_KEYS );

	// Dark blue background
	glClearColor(0.9f, 0.9f, 0.9f, 0.0f);

	glEnable(GL_DEPTH_TEST);

		// Initialize GLEW
	glewExperimental = true; // Needed for core profile
	if (glewInit() != GLEW_OK) {
		fprintf(stderr, "Failed to initialize GLEW
");
		return -1;
	}

	return 0;
}

EDIT:

Shaders are :


#version 330 core
	attribute vec3 aVertexPosition;
	attribute vec4 aVertexColor;

	uniform mat4 uMVMatrix;
	uniform mat4 uPMatrix;

	varying vec4 vColor;

	void main(void){
		gl_Position=uPMatrix*uMVMatrix*vec4(aVertexPosition, 1.0);
		vColor=aVertexColor;

	}


#version 330 core

	precision mediump float;

	varying vec4 vColor;

	void main(void){
		gl_FragColor=vColor;
	}


It compiles, but no cube is showed,it is surely a banal issue but I don’t know how to find it out.

Sorry for the probably stupid question and if my English is bad :slight_smile:

Thanks a lot!

Make sure


setMatrixUniform();

is loading both matrice uniforms

I don’t see where you are initialising uPMatrix


mvMatrix=glm::translate(mvMatrix, glm::vec3(-1.5f,0.0f,-8.0f));

Try using glm::lookAt to look at an object

[QUOTE=tonyo_au;1249723]Make sure


setMatrixUniform();

is loading both matrice uniforms

I don’t see where you are initialising uPMatrix


mvMatrix=glm::translate(mvMatrix, glm::vec3(-1.5f,0.0f,-8.0f));

Try using glm::lookAt to look at an object[/QUOTE]

Thanks for your reply.

Trying with gDebugger I see that uPMatrix is actually loaded, actually the uPMatrix is the uniform name in the shader whereas in my code the perspective matrix is pMatrix:

In initShaders


	program.pMatrixUniform=glGetUniformLocation(programID, "uPMatrix");

Before setMatrixUniforms

glm::mat4 pMatrix = glm::mat4(1.0);

and in setMatrixUniforms

glUniformMatrix4fv(program.pMatrixUniform, 1, GL_FALSE, &pMatrix[0][0]);

pMatrix is setted in drawScene:

	pMatrix=glm::perspective(45.0f, float(viewportWidth/viewporthHeight), 0.1f, 100.0f);

For lookAt, I will check it out, however even without translating it still doesn’t works, and what I need is a 1:1 port from my WebGL sample where I use translation.

Thanks again!

Hi,
First thing I need to ask, are you creating a valid OpenGL 3.3 context? If that was the case, the code should not have compiled in the first place. Now assuming you have a valid OpenGL 3.3 context, you cannot use gl_FragColor in OpenGL 3.3 core profile. you have to output your own attribute. You vertex shader also has to be changed as well to be a valid OpenGL 3.3 core profile vertex shader. Here is what I think should work if everything else is fine.

Here is the vertex shader


#version 330 core 

layout (location=0) in vec3 aVertexPosition; 
layout (location=1) in vec4 aVertexColor; 
  
uniform mat4 uMVMatrix; 
uniform mat4 uPMatrix;
smooth out vec4 vColor;   

void main(void) {    
    gl_Position=uPMatrix*uMVMatrix*vec4(aVertexPosition, 1.0);    
    vColor=aVertexColor; 
}

Here is the fragment shader


#version 330 core 

layout(location=0) out vec4 vFragColor;

smooth in vec4 vColor;

void main(void) {    
    vFragColor=vColor; 
}

See if this helps. You can go through this set of tutorials for learning modern OpenGL http://www.arcsynthesis.org/gltut/