Unable to view off-screen rendered mesh using mesa_glsl

Hi Brian,

Currently I am unable to view anything the render using glsl shader.
I have tried rendering a simple triangle in immediate mode and it renders
fine(off-screen).
But not able to clear background color.

My renderScene code for Immediate mode looks something like this:

glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);

// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);

// Cull triangles which normal is not towards the camera
glEnable(GL_CULL_FACE);

glBegin(GL_TRIANGLES);
glColor3f(0.5f, 0.0f, 0.0f);
glVertex3f(-1.0f, 0.0f, -1.0f);
glColor3f(0.0f, 0.5f, 0.0f);
glVertex3f(1.0f, 0.0f, -1.0f);
glColor3f(0.0f, 0.0f, 0.5f);
glVertex3f(0.0f, 1.0f, 0.0f);
glEnd();

glFinish();
SaveScreenGrab("mesa_snapshot.tga");


But same triangle using shader doesn't render at all. However the
glClearColor clears the screen color correctly.


Below is the bit of code that I took from (opengl.org) which render the
scene into a targa image.

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

// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);

// Create and compile our GLSL program from the shaders
GLuint programID = LoadShaders("camera.vertexshader",
"camera.fragmentshader");

// Get a handle for our "MVP" uniform
GLuint MatrixID = glGetUniformLocation(programID, "MVP");

// Get a handle for our buffers
GLuint vertexPosition_modelspaceID = glGetAttribLocation(programID,
"vertexPosition_modelspace");
GLuint vertexColorID = glGetAttribLocation(programID, "vertexColor");

// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1
unit <-> 100 units
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);

// Camera matrix
glm::mat4 View = glm::lookAt(
glm::vec3(4, 3, -3), // Camera is at (4,3,-3), in World Space
glm::vec3(0, 0, 0), // and looks at the origin
glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
);
// Model matrix : an identity matrix (model will be at the origin)
glm::mat4 Model = glm::mat4(1.0f);
// Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 MVP = Projection * View * Model; // Remember, matrix
multiplication is the other way around

GLuint vertexbuffer;
glGenBuffers(1, &vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data),
g_vertex_buffer_data, GL_STATIC_DRAW);

GLuint colorbuffer;
glGenBuffers(1, &colorbuffer);
glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_color_buffer_data),
g_color_buffer_data, GL_STATIC_DRAW);

// Clear the screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// Use our shader
glUseProgram(programID);

// Send our transformation to the currently bound shader,
// in the "MVP" uniform
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);

// 1rst attribute buffer : vertices
glEnableVertexAttribArray(vertexPosition_modelspaceID);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glVertexAttribPointer(
vertexPosition_modelspaceID, // The attribute we want to configure
3,                           // size
GL_FLOAT,                    // type
GL_FALSE,                    // normalized?
0,                           // stride
(void*)0                     // array buffer offset
);

// 2nd attribute buffer : colors
glEnableVertexAttribArray(vertexColorID);
glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
glVertexAttribPointer(
vertexColorID,               // The attribute we want to configure
3,                           // size
GL_FLOAT,                    // type
GL_FALSE,                    // normalized?
0,                           // stride
(void*)0                     // array buffer offset
);

// Draw the triangleS !
glDrawArrays(GL_TRIANGLES, 0, 12 * 3); // 12*3 indices starting at 0 -> 12
triangles


glDisableVertexAttribArray(vertexPosition_modelspaceID);
glDisableVertexAttribArray(vertexColorID);

SaveScreenGrab("mesa_snapshot.tga");

// Cleanup VBO and shader
glDeleteBuffers(1, &vertexbuffer);
glDeleteBuffers(1, &colorbuffer);
glDeleteProgram(programID);



*vertex shader code:*

#version 120

// Input vertex data, different for all executions of this shader.
attribute vec3 vertexPosition_modelspace;
attribute vec3 vertexColor;

// Output data ; will be interpolated for each fragment.
varying vec3 fragmentColor;
// Values that stay constant for the whole mesh.
uniform mat4 MVP;

void main(){

// Output position of the vertex, in clip space : MVP * position
gl_Position =  MVP * vec4(vertexPosition_modelspace,1);

// The color of each vertex will be interpolated
// to produce the color of each fragment
fragmentColor = vertexColor;
}

*fragment shader code:*

#version 120
// Interpolated values from the vertex shaders
varying vec3 fragmentColor;

void main(){

gl_FragColor = fragmentColor;

}



Please guide me if I am doing something wrong here.



Thanks & Regards,
Vikram

_______________________________________________
mesa-users mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/mesa-users