Okay, well. First of all, this is the first time I’ve tried using vertex buffers with shaders, and for whatever reason, nothing is showing up when I set it to render the object.
Here’s my render() function:
float mvMat[16] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 50, 1 };
//mvMat is supposed to be an identity matrix translated 50 units forward
float projMat[16];
void Render(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (vbo != 0 && ibo != 0)
{
float mvpMat[16];
m3dMatrixMultiply44(mvpMat, mvMat, projMat);
glUseProgram(progFlatColor);
glUniform4f(uniformColor, 1.0, 0.0, 1.0, 1.0);
glUniformMatrix4fv(uniformMVP, 1, 0, mvpMat);
// Draw the main object
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 20, (const GLvoid*)0);
glDrawElements(GL_TRIANGLES, activeHeader.numTris, GL_UNSIGNED_SHORT, 0);
// Draw the wireframe
// Draw normals
// Draw PhysX shapes
// Draw bounding box/sphere
printf("ERROR: %i
", glGetError());
}
SwapBuffers(g_hDC);
}
projMat is set up like so:
float fov = 70.0f;
float aspect = (rcClient.right/iRenderHeight);
float znear = 1.0f;
float zfar = 100.0f;
const float h = 1.0f/tan(fov*PI_OVER_360);
float neg_depth = znear-zfar;
projMat[0] = h / aspect;
projMat[1] = 0;
projMat[2] = 0;
projMat[3] = 0;
projMat[4] = 0;
projMat[5] = h;
projMat[6] = 0;
projMat[7] = 0;
projMat[8] = 0;
projMat[9] = 0;
projMat[10] = (zfar + znear)/neg_depth;
projMat[11] = -1;
projMat[12] = 0;
projMat[13] = 0;
projMat[14] = 2.0f*(znear*zfar)/neg_depth;
projMat[15] = 0;
And my SetupShaders() function looks like this:
unsigned long progFlatColor, progFlatTexture, progLitColor, progLitTexture;
int uniformColor, uniformMVP = -1;
bool DebugShader(unsigned int shader);
bool DebugProgram(unsigned int program);
const char VertSrcFlatColor[] =
"\
//Flat Shader - Vertex
\
//Displays unshaded shapes using a uniform color
\
#version 120
\
\
uniform mat4 MVP;
\
\
attribute vec4 position;
\
\
void main(void)
\
{
\
gl_Position = (position * MVP);
\
}
\
\0";
const char FragSrcFlatColor[] =
"\
//Flat Shader - Fragment
\
\
uniform vec4 color;
\
\
void main(void)
\
{
\
gl_FragColor = color;
\
}
\
\0";
enum ShaderMode
{
SM_NONE = 0,
SM_CORE,
SM_ARB
};
void SetupShaders(void)
{
//printf("INFO: vert shader:
%s", VertSrcFlatColor);
//printf("INFO: frag shader:
%s", FragSrcFlatColor);
ShaderMode sm = SM_NONE;
if (glewIsSupported("GL_VERSION_2_0"))
{
printf("INFO: Shaders supported natively in GL version 2.0 or higher.
");
sm = SM_CORE;
}
else if (GLEW_ARB_vertex_shader && GLEW_ARB_vertex_shader)
{
printf("INFO: Shaders supported via extensions.
");
sm = SM_ARB;
}
else
{
printf("ERROR: Shaders aren't supported.
");
sm = SM_NONE;
}
unsigned long vertShader, fragShader;
const char* vv = VertSrcFlatColor;
const char* ff = FragSrcFlatColor;
switch (sm)
{
case SM_CORE:
vertShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertShader, 1, &vv, NULL);
glCompileShader(vertShader);
if (!DebugShader(vertShader))
{
glDeleteShader(vertShader);
return;
}
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragShader, 1, &ff, NULL);
glCompileShader(fragShader);
if (!DebugShader(fragShader))
{
glDeleteShader(vertShader);
glDeleteShader(fragShader);
return;
}
progFlatColor = glCreateProgram();
glAttachShader(progFlatColor, vertShader);
glAttachShader(progFlatColor, fragShader);
glBindAttribLocation(progFlatColor, 0, "position");
glLinkProgram(progFlatColor);
glUseProgram(progFlatColor);
if (!DebugProgram(progFlatColor))
{
glDetachShader(progFlatColor, vertShader);
glDeleteShader(vertShader);
glDetachShader(progFlatColor, fragShader);
glDeleteShader(fragShader);
glDeleteProgram(progFlatColor);
return;
}
uniformColor = glGetUniformLocation(progFlatColor, "color");
uniformMVP = glGetUniformLocation(progFlatColor, "MVP");
if (uniformColor == -1 || uniformMVP == -1)
printf("ERROR: Could not find uniform locations.
");
glDeleteShader(vertShader);
glDeleteShader(fragShader);
break;
case SM_ARB:
vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
glShaderSourceARB(vertShader, 1, &vv, NULL);
glCompileShaderARB(vertShader);
fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(fragShader, 1, &ff, NULL);
glCompileShaderARB(fragShader);
progFlatColor = glCreateProgramObjectARB();
glAttachObjectARB(progFlatColor, vertShader);
glAttachObjectARB(progFlatColor, fragShader);
glLinkProgramARB(progFlatColor);
glUseProgramObjectARB(progFlatColor);
break;
default:
return;
break;
}
printf("INFO: Shaders successfully initialized.
");
}
I’m about 99% sure that the buffers are getting filled properly - I printf’d the entire array of vertices, and they look correct.