Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 4 of 4

Thread: Cube not rendering

  1. #1
    Junior Member Newbie
    Join Date
    Apr 2013
    Posts
    6

    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)

    Code :
    // 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\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 :

    Code :
    #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;
     
    	}
    Code :
    #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!
    Last edited by cifacia; 04-09-2013 at 12:41 PM.

  2. #2
    Senior Member OpenGL Pro
    Join Date
    Jan 2012
    Location
    Australia
    Posts
    1,106
    Make sure

    Code :
    setMatrixUniform();

    is loading both matrice uniforms

    I don't see where you are initialising uPMatrix

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

    Try using glm::lookAt to look at an object

  3. #3
    Junior Member Newbie
    Join Date
    Apr 2013
    Posts
    6
    Quote Originally Posted by tonyo_au View Post
    Make sure

    Code :
    setMatrixUniform();

    is loading both matrice uniforms

    I don't see where you are initialising uPMatrix

    Code :
    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
    Code :
    	program.pMatrixUniform=glGetUniformLocation(programID, "uPMatrix");

    Before setMatrixUniforms

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

    and in setMatrixUniforms
    Code :
    glUniformMatrix4fv(program.pMatrixUniform, 1, GL_FALSE, &pMatrix[0][0]);

    pMatrix is setted in drawScene:

    Code :
    	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!

  4. #4
    Advanced Member Frequent Contributor
    Join Date
    Mar 2009
    Location
    Singapore
    Posts
    800
    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
    Code :
    #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
    Code :
    #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/
    Last edited by mobeen; 04-10-2013 at 04:43 AM.
    Regards,
    Mobeen

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •