如何不在OpenGL中使用着色器覆盖顶点颜色？

Question

For the past three hours I am trying to figure out how to draw two different triangles with different colours using shaders in OpenGL and still cannot figure it out. Here is my code:

void setShaders(void)
{

  vshader = loadShader("test.vert", GL_VERTEX_SHADER_ARB);
  fshader = loadShader("test.frag", GL_FRAGMENT_SHADER_ARB);
  vshader2 = loadShader("test2.vert", GL_VERTEX_SHADER_ARB);
  fshader2 = loadShader("test2.frag", GL_FRAGMENT_SHADER_ARB);

  shaderProg = glCreateProgramObjectARB();
  glAttachObjectARB(shaderProg, vshader);
  glAttachObjectARB(shaderProg, fshader);
  glLinkProgramARB(shaderProg);

  shaderProg2 = glCreateProgramObjectARB();
  glAttachObjectARB(shaderProg2, vshader2);
  glAttachObjectARB(shaderProg2, fshader2);
  glLinkProgramARB(shaderProg2);

}

void makeBuffers(void)
{
// smaller orange triangle
  glGenBuffers (1, &vbo);
  glBindBuffer (GL_ARRAY_BUFFER, vbo);
  glBufferData (GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

  glGenVertexArrays (1, &vao);
  glBindVertexArray (vao);
  glEnableVertexAttribArray (0);
  glBindBuffer (GL_ARRAY_BUFFER, vbo);
  glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

// larger purple triangle
  glGenBuffers (1, &vbo2);
  glBindBuffer (GL_ARRAY_BUFFER, vbo2);
  glBufferData (GL_ARRAY_BUFFER, sizeof(points2), points2, GL_STATIC_DRAW);

  glGenVertexArrays (1, &vao2);
  glBindVertexArray (vao2);
  glEnableVertexAttribArray (0);
  glBindBuffer (GL_ARRAY_BUFFER, vbo2);
  glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

}

void window::displayCallback(void)
{
  Matrix4 m4;           // MT = UT * SpinMatrix
  m4 = cube.getMatrix();      //  make copy of the cube main matrix
  cube.get_spin().mult(m4);       //  mult 

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // clear color and depth buffers
  glMatrixMode(GL_MODELVIEW);
  glLoadMatrixd(cube.get_spin().getPointer());  // pass the pointer to new MT matrix 

  // draw smaller orange triangle
  glUseProgramObjectARB(shaderProg);

  glBindVertexArray(vao);
  glDrawArrays (GL_TRIANGLES, 0, 3);

  glDeleteObjectARB(shaderProg);

  // draw the larger purple triangle
  glUseProgramObjectARB(shaderProg2);

  glBindVertexArray(vao2);
  glDrawArrays (GL_TRIANGLES, 0, 3);

  glDeleteObjectARB(shaderProg2);

  glFlush();
  glutSwapBuffers();
}

shaders:

test.vert and test2.vert are the same and are:

#version 120

//varying vec3 vp; 

void main()
{
  gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

test.frag:

#version 120

void main()
{
  gl_FragColor = vec4(1.0, 0.5, 0.0, 1.0);
}

test2.frag:

#version 120

void main()
{
  gl_FragColor = vec4(0.5, 0.0, 0.5, 1.0);
}

But what I get is two triangles that are coloured purple. What am I doing wrong that causes my smaller orange triangle is getting rewritten in purple colour?

Answer 1

You are deleting the shader programs after you use them in the displayCallback() method:

...
glDrawArrays (GL_TRIANGLES, 0, 3);
glDeleteObjectARB(shaderProg);

...
glDrawArrays (GL_TRIANGLES, 0, 3);
glDeleteObjectARB(shaderProg2);

If drawCallback() is called more than once, which you certainly need to expect since a window will often have to be redrawn multiple times, the shaders will be gone after the first time. In fact, the second one will not be immediately deleted because it is the currently active program. Which explains why it continues to be used for both triangles.

Shader programs are only deleted after glDelete*() is called on them, and they are not referenced as the active program. So on your first glDelete*() call for shaderProg , that program is deleted once you make shaderProg2 active, because shaderProg is then not active anymore, which releases its last reference.

You should not delete the shader programs until shutdown, or until you don't plan to use them anymore for rendering because eg you're creating new prgrams. So in your case, you can delete them when the application exits. At least that's often considered good style, even though it's not technically necessary. OpenGL resources will be cleaned up automatically when an application exits, similar to regular memory allocations.

BTW, if you are using at least OpenGL 2.0, all the calls for using shaders and programs are core functionality. There's no need to use the ARB version calls.