OpenSubdiv/examples/common/gl_hud.cpp

//
//     Copyright 2013 Pixar
//
//     Licensed under the Apache License, Version 2.0 (the "License");
//     you may not use this file except in compliance with the License
//     and the following modification to it: Section 6 Trademarks.
//     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 for reproducing
//     the content of the NOTICE file.
//
//     You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
//     either express or implied.  See the License for the specific
//     language governing permissions and limitations under the
//     License.
//

#include "gl_hud.h"

#include "font_image.h"
#include "simple_math.h"

#include <string.h>
#include <stdio.h>

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() : _fontTexture(0), _vbo(0), _staticVbo(0),
                 _vao(0), _staticVao(0), _program(0),
                 _aPosition(0), _aColor(0), _aUV(0)
{
}

GLhud::~GLhud()
{
    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);
}

static GLuint compileShader(GLenum shaderType, const char *source)
{
    GLuint shader = glCreateShader(shaderType);
    glShaderSource(shader, 1, &source, NULL);
    glCompileShader(shader);

    return shader;
}

void
GLhud::Init(int width, int height)
{
    Hud::Init(width, height);
    
    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);
}

void
GLhud::Rebuild(int width, int height)
{
    Hud::Rebuild(width, height);

    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);
}

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;
}