text: //
  //   Copyright 2013 Pixar
  //
  //   Licensed under the Apache License, Version 2.0 (the "Apache License")
  //   with the following modification; you may not use this file except in
  //   compliance with the Apache License and the following modification to it:
  //   Section 6. Trademarks. is deleted and replaced with:
  //
  //   6. Trademarks. This License does not grant permission to use the trade
  //      names, trademarks, service marks, or product names of the Licensor
  //      and its affiliates, except as required to comply with Section 4(c) of
  //      the License and to reproduce the content of the NOTICE file.
  //
  //   You may obtain a copy of the Apache License at
  //
  //       http://www.apache.org/licenses/LICENSE-2.0
  //
  //   Unless required by applicable law or agreed to in writing, software
  //   distributed under the Apache License with the above modification is
  //   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  //   KIND, either express or implied. See the Apache License for the specific
  //   language governing permissions and limitations under the Apache License.
  //
  
  #include "gl_hud.h"
  #include "gl_common.h"
  
  #include "font_image.h"
  #include "simple_math.h"
  
  #include <cstdlib>
  #include <cstring>
  #include <cstdio>
  #include <cassert>
  #include <iostream>
  
  static const char *s_VS =
  #if defined(GL_VERSION_3_1)
      "#version 150\n"
      "in vec2 position;\n"
      "in vec3 color;\n"
      "in vec2 uv;\n"
      "out vec4 fragColor;\n"
      "out vec2 fragUV;\n"
      "uniform mat4 ModelViewProjectionMatrix;\n"
      "void main() {\n"
      "  fragColor = vec4(color, 1);\n"
      "  fragUV = uv;\n"
      "  gl_Position = ModelViewProjectionMatrix * "
      "                  vec4(position.x, position.y, 0, 1);\n"
      "}\n";
  #else
      "attribute vec2 position;\n"
      "attribute vec3 color;\n"
      "attribute vec2 uv;\n"
      "varying vec4 fragColor;\n"
      "varying vec2 fragUV;\n"
      "uniform mat4 ModelViewProjectionMatrix;\n"
      "void main() {\n"
      "  fragColor = vec4(color, 1);\n"
      "  fragUV = uv;\n"
      "  gl_Position = ModelViewProjectionMatrix * "
      "                  vec4(position.x, position.y, 0, 1);\n"
      "}\n";
  #endif
  
  static const char *s_FS =
  #if defined(GL_VERSION_3_1)
      "#version 150\n"
      "in vec4 fragColor;\n"
      "in vec2 fragUV;\n"
      "out vec4 color;\n"
      "uniform sampler2D fontTexture;\n"
      "void main() {\n"
      "  vec4 c = texture(fontTexture, fragUV);\n"
      "  if (c.a == 0.0) discard;\n"
      "  color = c*fragColor;\n"
      "}\n";
  #else
      "varying vec4 fragColor;\n"
      "varying vec2 fragUV;\n"
      "uniform sampler2D fontTexture;\n"
      "void main()\n"
      "{\n"
      "  vec4 c = texture2D(fontTexture, fragUV);\n"
      "  if (c.a == 0.0) discard;\n"
      "  gl_FragColor = c*fragColor;\n"
      "}\n";
  #endif
  
  GLhud::GLhud() : _frameBuffer(0), _fontTexture(0), _vbo(0), _staticVbo(0),
                   _vao(0), _staticVao(0), _program(0),
                   _aPosition(0), _aColor(0), _aUV(0)
  {
  }
  
  GLhud::~GLhud()
  {
      if (_frameBuffer)
          delete _frameBuffer;
      if (_program)
          glDeleteProgram(_program);
      if (_fontTexture)
          glDeleteTextures(1, &_fontTexture);
      if (_vbo)
          glDeleteBuffers(1, &_vbo);
      if (_staticVbo)
          glDeleteBuffers(1, &_staticVbo);
      if (_vao)
          glDeleteVertexArrays(1, &_vao);
      if (_staticVao)
          glDeleteVertexArrays(1, &_staticVao);
  }
  
  void
  GLhud::Init(int width, int height, int frameBufferWidth, int frameBufferHeight)
  {
      Hud::Init(width, height, frameBufferWidth, frameBufferHeight);
  
      glGenTextures(1, &_fontTexture);
      glBindTexture(GL_TEXTURE_2D, _fontTexture);
  
      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
                   FONT_TEXTURE_WIDTH, FONT_TEXTURE_HEIGHT,
                   0, GL_RGBA, GL_UNSIGNED_BYTE, font_image);
  
      glGenBuffers(1, &_vbo);
      glGenBuffers(1, &_staticVbo);
  
      glGenVertexArrays(1, &_vao);
      glGenVertexArrays(1, &_staticVao);
  
      GLuint vertexShader = compileShader(GL_VERTEX_SHADER, s_VS);
      GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, s_FS);
  
      _program = glCreateProgram();
      glAttachShader(_program, vertexShader);
      glAttachShader(_program, fragmentShader);
  
      glLinkProgram(_program);
  
      glDeleteShader(vertexShader);
      glDeleteShader(fragmentShader);
  
      GLint status;
      glGetProgramiv(_program, GL_LINK_STATUS, &status);
      if (status == GL_FALSE) {
          GLint infoLogLength;
          glGetProgramiv(_program, GL_INFO_LOG_LENGTH, &infoLogLength);
          char *infoLog = new char[infoLogLength];
          glGetProgramInfoLog(_program, infoLogLength, NULL, infoLog);
          printf("%s\n", infoLog);
          delete[] infoLog;
      }
  
      _mvpMatrix = glGetUniformLocation(_program, "ModelViewProjectionMatrix");
      _aPosition = glGetAttribLocation(_program, "position");
      _aColor = glGetAttribLocation(_program, "color");
      _aUV = glGetAttribLocation(_program, "uv");
  
      glBindVertexArray(_vao);
      glEnableVertexAttribArray(_aPosition);
      glEnableVertexAttribArray(_aColor);
      glEnableVertexAttribArray(_aUV);
      glBindBuffer(GL_ARRAY_BUFFER, _vbo);
      glVertexAttribPointer(_aPosition, 2, GL_FLOAT, GL_FALSE,
                            sizeof(GLfloat)*7, (void*)0);
      glVertexAttribPointer(_aColor, 3, GL_FLOAT, GL_FALSE,
                            sizeof(GLfloat)*7, (void*)(sizeof(GLfloat)*2));
      glVertexAttribPointer(_aUV, 2, GL_FLOAT, GL_FALSE,
                            sizeof(GLfloat)*7, (void*)(sizeof(GLfloat)*5));
  
      glBindVertexArray(_staticVao);
      glEnableVertexAttribArray(_aPosition);
      glEnableVertexAttribArray(_aColor);
      glEnableVertexAttribArray(_aUV);
      glBindBuffer(GL_ARRAY_BUFFER, _staticVbo);
      glVertexAttribPointer(_aPosition, 2, GL_FLOAT, GL_FALSE,
                            sizeof(GLfloat)*7, (void*)0);
      glVertexAttribPointer(_aColor, 3, GL_FLOAT, GL_FALSE,
                            sizeof(GLfloat)*7, (void*)(sizeof(GLfloat)*2));
      glVertexAttribPointer(_aUV, 2, GL_FLOAT, GL_FALSE,
                            sizeof(GLfloat)*7, (void*)(sizeof(GLfloat)*5));
  
      glBindVertexArray(0);
  
      glBindBuffer(GL_ARRAY_BUFFER, 0);
  
      checkGLErrors("GLhud::Init");
  }
  
  void
  GLhud::Rebuild(int width, int height, int framebufferWidth, int framebufferHeight)
  {
      Hud::Rebuild(width, height, framebufferWidth, framebufferHeight);
  
      if (not _staticVbo)
          return;
  
      _staticVboSize = (int)getStaticVboSource().size();
      glBindBuffer(GL_ARRAY_BUFFER, _staticVbo);
      glBufferData(GL_ARRAY_BUFFER, _staticVboSize * sizeof(float),
                   &getStaticVboSource()[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
  
      if (GetFrameBuffer()) {
          GetFrameBuffer()->Reshape(framebufferWidth, framebufferHeight);
      }
  }
  
  bool
  GLhud::Flush()
  {
      if (!Hud::Flush())
          return false;
  
      // update dynamic text
      glBindVertexArray(_vao);
      glBindBuffer(GL_ARRAY_BUFFER, _vbo);
      glBufferData(GL_ARRAY_BUFFER, getVboSource().size() * sizeof(float),
                   &getVboSource()[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
      // (x, y, r, g, b, u, v) = 7
      int numVertices = (int)getVboSource().size()/7;
  
      // reserved space of the vector remains for the next frame.
      getVboSource().clear();
      glUseProgram(_program);
      float proj[16];
      ortho(proj, 0, 0, float(GetWidth()), float(GetHeight()));
      glUniformMatrix4fv(_mvpMatrix, 1, GL_FALSE, proj);
  
      {
          glActiveTexture(GL_TEXTURE0);
          glBindTexture(GL_TEXTURE_2D, _fontTexture);
  
          glBindVertexArray(_vao);
          glDrawArrays(GL_TRIANGLES, 0, numVertices);
  
          glBindVertexArray(_staticVao);
          glDrawArrays(GL_TRIANGLES, 0, _staticVboSize/7);
  
          glBindTexture(GL_TEXTURE_2D, 0);
      }
  
      return true;
  }
  