PDA

View Full Version : Cube not rendering



cifacia
04-09-2013, 11:39 AM
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=glGetAttribLocatio n(programID, "aVertexPosition");
glEnableVertexAttribArray(program.vertexPositionAt tribute);
program.vertexColorAttribute=glGetAttribLocation(p rogramID, "aVertexColor");
glEnableVertexAttribArray(program.vertexColorAttri bute);
program.pMatrixUniform=glGetUniformLocation(progra mID, "uPMatrix");
program.mvMatrixUniform=glGetUniformLocation(progr amID, "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\n" );
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.\n" );
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\n");
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(aVertexPositio n, 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 :)

Thanks a lot!

tonyo_au
04-09-2013, 06:42 PM
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

cifacia
04-10-2013, 02:03 AM
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

Thanks for your reply.

1)
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(progra mID, "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!

mobeen
04-10-2013, 05:33 AM
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(aVertexPositio n, 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/