OpenGL 4.1: Triangle Flashes and Disappears Immediately after Being Drawn

Question

I want to render a green triangle.

• OpenGL Version: 4.1
• Shading Language Version: 4.10

Problem

The code below, when executed, shows a green triangle that flashes for an instant and disappears.

I saw this post: A red rectangle drawn on 2D texture disappears right after being drawn, who has a similar issue of disappearing triangles, but his was because he called Swap Buffer multiple times, but I only have one instance of glutSwapBuffers() in the displayFunc().

C++ Code:

#include <iostream>
#include "OpenGLMatrix.h"
#include "BasicPipelineProgram.h"
using namespace std;

int windowWidth = 1280;
int windowHeight = 720;
char windowTitle[512] = "Simple Green Triangle";

// global variables
OpenGLMatrix *matrix;
GLuint buffer;
BasicPipelineProgram *pipelineProgram;
GLint program;
GLuint vao;

// objects to render
int numVertices = 3;
float positions[9] =
  { -1, -1, -1,
     1, -1, -1,
    -1,  1, -1  };   // 3 vertices of triangle to render
float colors[12] =
  { 0, 1, 0, 1,
    0, 1, 0, 1,
    0, 1, 0, 1 }; // all vertices green with alpha = 1

void bindProgram() {
  // upload model view matrix to shader
  float m[16];
  matrix->SetMatrixMode(OpenGLMatrix::ModelView);
  matrix->GetMatrix(m);
  pipelineProgram->SetModelViewMatrix(m);

  // upload projection matrix to shader
  float p[16];
  matrix->SetMatrixMode(OpenGLMatrix::Projection);
  matrix->GetMatrix(p);
  pipelineProgram->SetProjectionMatrix(p);
}

void displayFunc() {
  // computing modelview matrix
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  matrix->LoadIdentity();

  // camera at (0,0,1), looking in -z direction, up vector y
  matrix->LookAt(0, 0, 1, 0, 0, -1, 0, 1, 0); 

  bindProgram();

  // use the VAO
  pipelineProgram->Bind();
  glBindVertexArray(vao);
  GLint first = 0;
  GLsizei count = numVertices;
  glDrawArrays(GL_TRIANGLES, first, count);
  glBindVertexArray(0);

  glutSwapBuffers();
}

void idleFunc() {
  // make the screen update 
  glutPostRedisplay();
}

void reshapeFunc(int w, int h) {
  GLfloat aspect = (GLfloat) w / (GLfloat) h;
  glViewport(0, 0, w, h);

  // setup perspective matrix
  matrix->SetMatrixMode(OpenGLMatrix::Projection);
  matrix->LoadIdentity();
  matrix->Perspective(60.0, aspect, 0.01, 1000.0);
  matrix->SetMatrixMode(OpenGLMatrix::ModelView);
}

void initPipelineProgram() {
  // initialize shader pipeline program
  pipelineProgram = new BasicPipelineProgram();
  pipelineProgram->Init();
  pipelineProgram->Bind();
  program = pipelineProgram->GetProgramHandle();

  // VAO (vertex array objects) to contain the VBOs
  glGenVertexArrays(1, &vao);
  glBindVertexArray(vao);
  glBindBuffer(GL_ARRAY_BUFFER, buffer);

  // get location index of the "position" shader variable
  GLuint loc = glGetAttribLocation(program, "position");
  glEnableVertexAttribArray(loc);
  const void *offset = (const void*) 0;
  GLsizei stride = 0;
  GLboolean normalized = GL_FALSE;
  glVertexAttribPointer(loc, 3, GL_FLOAT, normalized, stride, offset);

  // get location index of the "color" shader variable
  loc = glGetAttribLocation(program, "color");
  glEnableVertexAttribArray(loc);
  offset = (const void*) sizeOfPositions;
  stride = 0;
  normalized = GL_FALSE;
  glVertexAttribPointer(loc, 4, GL_FLOAT, normalized, stride, offset);

  glBindVertexArray(0);
}

void initVBO() {
  glGenBuffers(1, &buffer);
  glBindBuffer(GL_ARRAY_BUFFER, buffer);
  glBufferData(GL_ARRAY_BUFFER, sizeOfPositions + sizeOfColors, NULL, GL_STATIC_DRAW);

  // upload position data
  glBufferSubData(GL_ARRAY_BUFFER, 0, sizeOfPositions, positions);

  // upload color data
  glBufferSubData(GL_ARRAY_BUFFER, sizeOfPositions, sizeOfColors, colors);
}

void initScene(int argc, char *argv[])
{
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  glEnable(GL_DEPTH_TEST);
  matrix = new OpenGLMatrix();
  initVBO();
  initPipelineProgram();
}

int main(int argc, char *argv[])
{
  cout << "Initializing GLUT..." << endl;
  glutInit(&argc,argv);

  cout << "Initializing OpenGL..." << endl;

  #ifdef __APPLE__
    glutInitDisplayMode(GLUT_3_2_CORE_PROFILE | GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL);
  #else
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL);
  #endif

  glutInitWindowSize(windowWidth, windowHeight);
  glutInitWindowPosition(0, 0);  
  glutCreateWindow(windowTitle);

  // glut callback functions
  glutDisplayFunc(displayFunc);
  glutIdleFunc(idleFunc);
  glutReshapeFunc(reshapeFunc);

  initScene(argc, argv);
  glutMainLoop();
}

In the code, OpenGLMatrix *matrix and BasicPipelineProgram *pipelineProgram are classes defined elsewhere, and whose code, unless requested, I don't think we need to worry about. "position" and "color" in initPipelineProgram() refer to variables in the GLSL shader specification:

#version 150

in vec3 position;
in vec4 color;
out vec4 col;

uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;

void main()
{
  // compute the transformed and projected vertex position (into gl_Position) 
  // compute the vertex color (into col)

  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0f);
  col = color;
}

I don't understand why the triangle flashes and then immediately disappears??

I'm a beginner in OpenGL and any help is greatly appreciated. Thank you!