title: multiple glut windows but same display function
body: <p>I am trying to render the model in two windows in glut. But it is rendered in only one of the windows. Is it possible to render in two windows with different callback functions? </p>
  
  <pre><code>#include &lt;stdlib.h&gt;
  #include &lt;stdio.h&gt;
  #include &lt;string.h&gt;
  #include &lt;GL/glew.h&gt;
  #include &lt;GL/freeglut.h&gt;
  #define WINDOW_TITLE_PREFIX "Chapter 2"
  
  int CurrentWidth = 800,
      CurrentHeight = 600,
      WindowHandle = 0;
  
  unsigned FrameCount = 0;
  
  GLuint
      VertexShaderId,
      FragmentShaderId,
      ProgramId,
      VaoId,
      VboId,
      ColorBufferId;
  
  const GLchar* VertexShader =
  {
      "#version 400\n"\
  
      "layout(location=0) in vec4 in_Position;\n"\
      "layout(location=1) in vec4 in_Color;\n"\
      "out vec4 ex_Color;\n"\
  
      "void main(void)\n"\
      "{\n"\
      "   gl_Position = in_Position;\n"\
      "   ex_Color = in_Color;\n"\
      "}\n"
  };
  
  const GLchar* FragmentShader =
  {
      "#version 400\n"\
  
      "in vec4 ex_Color;\n"\
      "out vec4 out_Color;\n"\
  
      "void main(void)\n"\
      "{\n"\
      "   out_Color = ex_Color;\n"\
      "}\n"
  };
  
  void Initialize(int, char*[]);
  void InitWindow(int, char*[]);
  void ResizeFunction(int, int);
  void ResizeFunction1(int, int);
  void RenderFunction(void);
  void RenderFunction1(void);
  void TimerFunction(int);
  void TimerFunction1(int);
  void IdleFunction(void);
  void IdleFunction1(void);
  void Cleanup(void);
  void CreateVBO(void);
  void DestroyVBO(void);
  void CreateShaders(void);
  void DestroyShaders(void);
  
  int Wh1;
  
  int main(int argc, char* argv[])
  {
      Initialize(argc, argv);
  
      glutMainLoop();
  
      exit(EXIT_SUCCESS);
  }
  
  void Initialize(int argc, char* argv[])
  {
      GLenum GlewInitResult;
  
      InitWindow(argc, argv);
  
      glewExperimental = GL_TRUE;
      GlewInitResult = glewInit();
  
      if (GLEW_OK != GlewInitResult) {
          fprintf(
              stderr,
              "ERROR: %s\n",
              glewGetErrorString(GlewInitResult)
          );
          exit(EXIT_FAILURE);
      }
  
      fprintf(
          stdout,
          "INFO: OpenGL Version: %s\n",
          glGetString(GL_VERSION)
      );
  
      CreateShaders();
      CreateVBO();
  
      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  }
  
  void InitWindow(int argc, char* argv[])
  {
      glutInit(&amp;argc, argv);
  
      glutInitContextVersion(4, 0);
      glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
      glutInitContextProfile(GLUT_CORE_PROFILE);
  
      glutSetOption(
          GLUT_ACTION_ON_WINDOW_CLOSE,
          GLUT_ACTION_GLUTMAINLOOP_RETURNS
      );
  
      glutInitWindowSize(CurrentWidth, CurrentHeight);
  
      glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
  
      WindowHandle = glutCreateWindow(WINDOW_TITLE_PREFIX);
      std::cout&lt;&lt;WindowHandle&lt;&lt;std::endl;
      if(WindowHandle &lt; 1) {
          fprintf(
              stderr,
              "ERROR: Could not create a new rendering window.\n"
          );
          exit(EXIT_FAILURE);
      }
      glutSetWindow(WindowHandle);
      glutReshapeFunc(ResizeFunction);
      glutDisplayFunc(RenderFunction);
      glutTimerFunc(0, TimerFunction, 0);
      glutCloseFunc(Cleanup);
  #if 1
      Wh1 = glutCreateWindow("sasd"); 
  //  std::cout&lt;&lt;i&lt;&lt;"s"&lt;&lt;std::endl;
      glutReshapeFunc(ResizeFunction1);
      glutDisplayFunc(RenderFunction1);
      glutTimerFunc(0, TimerFunction1, 0);
      glutCloseFunc(Cleanup);
      glutSetWindow(Wh1);
  #endif
  
  }
  
  void ResizeFunction(int Width, int Height)
  {
      CurrentWidth = Width;
      CurrentHeight = Height;
      glViewport(0, 0, CurrentWidth, CurrentHeight);
  }
  
  
  void ResizeFunction1(int Width, int Height)
  {
      CurrentWidth = Width;
      CurrentHeight = Height;
      glViewport(0, 0, CurrentWidth, CurrentHeight);
  }
  
  void RenderFunction(void)
  {
      ++FrameCount;
  
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
      glDrawArrays(GL_TRIANGLES, 0, 3);
  
      glutSwapBuffers();
      glutSetWindow(WindowHandle);
      glutPostRedisplay();
      glutSetWindow(Wh1);
      glutPostRedisplay();
  }
  
  void RenderFunction1(void)
  {
      ++FrameCount;
  
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
      glDrawArrays(GL_TRIANGLES, 0, 3);
  
      glutSwapBuffers();
  
      glutSetWindow(WindowHandle);
      glutPostRedisplay();
      glutSetWindow(Wh1);
      glutPostRedisplay();
  }
  
  void IdleFunction(void)
  {
      glutSetWindow(WindowHandle);
      glutPostRedisplay();
      glutSetWindow(Wh1);
      glutPostRedisplay();
  }
  
  void IdleFunction1(void)
  {
      glutSetWindow(WindowHandle);
      glutPostRedisplay();
      glutSetWindow(Wh1);
      glutPostRedisplay();
  }
  void TimerFunction(int Value)
  {
      if (0 != Value) {
          char* TempString = (char*)
              malloc(512 + strlen(WINDOW_TITLE_PREFIX));
  
          sprintf(
              TempString,
              "%s: %d Frames Per Second @ %d x %d",
              WINDOW_TITLE_PREFIX,
              FrameCount * 4,
              CurrentWidth,
              CurrentHeight
          );
  
          //glutSetWindowTitle(TempString);
          free(TempString);
      }
  
      FrameCount = 0;
      glutTimerFunc(250, TimerFunction, 1);
  }
  void TimerFunction1(int Value)
  {
      if (0 != Value) {
          char* TempString = (char*)
              malloc(512 + strlen(WINDOW_TITLE_PREFIX));
  
          sprintf(
              TempString,
              "%s: %d Frames Per Second @ %d x %d",
              WINDOW_TITLE_PREFIX,
              FrameCount * 4,
              CurrentWidth,
              CurrentHeight
          );
  
          //glutSetWindowTitle(TempString);
          free(TempString);
      }
  
      FrameCount = 0;
      glutTimerFunc(250, TimerFunction, 1);
  }
  
  void Cleanup(void)
  {
      DestroyShaders();
      DestroyVBO();
  }
  
  void CreateVBO(void)
  {
      GLfloat Vertices[] = {
          -0.8f, -0.8f, 0.0f, 1.0f,
           0.0f,  0.8f, 0.0f, 1.0f,
           0.8f, -0.8f, 0.0f, 1.0f
      };
  
      GLfloat Colors[] = {
          1.0f, 0.0f, 0.0f, 1.0f,
          0.0f, 1.0f, 0.0f, 1.0f,
          0.0f, 0.0f, 1.0f, 1.0f
      };
  
      GLenum ErrorCheckValue = glGetError();
  
      glGenVertexArrays(1, &amp;VaoId);
      glBindVertexArray(VaoId);
  
      glGenBuffers(1, &amp;VboId);
      glBindBuffer(GL_ARRAY_BUFFER, VboId);
      glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
      glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(0);
  
      glGenBuffers(1, &amp;ColorBufferId);
      glBindBuffer(GL_ARRAY_BUFFER, ColorBufferId);
      glBufferData(GL_ARRAY_BUFFER, sizeof(Colors), Colors, GL_STATIC_DRAW);
      glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(1);
  
      ErrorCheckValue = glGetError();
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not create a VBO: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
  }
  
  void DestroyVBO(void)
  {
      GLenum ErrorCheckValue = glGetError();
  
      glDisableVertexAttribArray(1);
      glDisableVertexAttribArray(0);
  
      glBindBuffer(GL_ARRAY_BUFFER, 0);
  
      glDeleteBuffers(1, &amp;ColorBufferId);
      glDeleteBuffers(1, &amp;VboId);
  
      glBindVertexArray(0);
      glDeleteVertexArrays(1, &amp;VaoId);
  
      ErrorCheckValue = glGetError();
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not destroy the VBO: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
  }
  
  void CreateShaders(void)
  {
      GLenum ErrorCheckValue = glGetError();
  
      VertexShaderId = glCreateShader(GL_VERTEX_SHADER);
      glShaderSource(VertexShaderId, 1, &amp;VertexShader, NULL);
      glCompileShader(VertexShaderId);
  
      FragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
      glShaderSource(FragmentShaderId, 1, &amp;FragmentShader, NULL);
      glCompileShader(FragmentShaderId);
  
      ProgramId = glCreateProgram();
          glAttachShader(ProgramId, VertexShaderId);
          glAttachShader(ProgramId, FragmentShaderId);
      glLinkProgram(ProgramId);
      glUseProgram(ProgramId);
  
      ErrorCheckValue = glGetError();
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not create the shaders: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
  }
  
  void DestroyShaders(void)
  {
      GLenum ErrorCheckValue = glGetError();
  
      glUseProgram(0);
  
      glDetachShader(ProgramId, VertexShaderId);
      glDetachShader(ProgramId, FragmentShaderId);
  
      glDeleteShader(FragmentShaderId);
      glDeleteShader(VertexShaderId);
  
      glDeleteProgram(ProgramId);
  
      ErrorCheckValue = glGetError();
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not destroy the shaders: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
  }
  </code></pre>