tinygl-cpp.h

#ifndef tinygl_cpp_H_
#define tinygl_cpp_H_
 
#include <stdio.h>
#include <iostream>
#include <vector>
#include <map>
#include <cmath>
 
#if ( (defined(__MACH__)) && (defined(__APPLE__)) )
#define GLFW_INCLUDE_GLCOREARB
#include <GLFW/glfw3.h>
#include <OpenGL/gl3ext.h>
#else
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#endif
#define STB_IMAGE_IMPLEMENTATION
#include "stb/stb_image.h"
 
namespace tinygl {
 
static void error_callback(int error, const char* description) {
  fputs("\n", stderr);
  fputs(description, stderr);
  fputs("\n", stderr);
}
 
const GLchar* vertexShader[] =
{
"#version 400\n"
"uniform vec4 inColor;"
"uniform vec3 inSize;"
"uniform vec3 inPos;"
"uniform float inScreenWidth;"
"uniform float inScreenHeight;"
"in vec3 VertexPosition;"
"out vec2 uv;"
"out vec4 color;"
"void main() {"
"  color = inColor;"
"  uv = (VertexPosition + 0.5).xy;"
"  vec4 x = vec4(2.0 / inScreenWidth, 0.0, 0.0, 0.0);"
"  vec4 y = vec4(0.0, 2.0 / inScreenHeight, 0.0, 0.0);"
"  vec4 z = vec4(0.0, 0.0, -2.0 / 2000, 0.0);"
"  vec4 d = vec4(-1.0, -1.0, 0.0, 1.0);"
"  mat4 projection = mat4(x, y, z, d);"
"  vec3 pos = inSize * VertexPosition + inPos;"
"  gl_Position = projection * vec4(pos, 1.0);"
"}"
};
 
const GLchar* fragmentShader[] =
{
"#version 400\n"
"uniform sampler2D inImage;"
"in vec4 color;"
"in vec2 uv;"
"out vec4 FragColor;"
"void main() { FragColor = color * texture(inImage, uv); }"
};
 
 
static void PrintShaderErrors(GLuint id, const std::string& label)
{
   std::cerr << label << " failed\n";
   GLint logLen;
   glGetShaderiv(id, GL_INFO_LOG_LENGTH, &logLen);
   if (logLen > 0)
   {
      char* log = (char*)malloc(logLen);
      GLsizei written;
      glGetShaderInfoLog(id, logLen, &written, log);
      std::cerr << "Shader log: " << log << std::endl;
      free(log);
   }
}
static class Window* theInstance = 0;
 
class Window {
 public:
  Window(int width, int height) :
    _windowWidth(width),
    _windowHeight(height),
    _elapsedTime(0.0),
    _dt(-1.0) {
 
    theInstance = this;
    glfwSetErrorCallback(error_callback);
 
    if (!glfwInit()) {
        fprintf(stderr, "ERROR: Cannot initialize GLFW\n");
        return;
    }
 
    // Set the GLFW window creation hints - these are optional
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
    glfwWindowHint(GLFW_SAMPLES, 4);  // Request 4x antialiasing
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 
    _window = glfwCreateWindow(_windowWidth, _windowHeight, "TinyGL C++ Window", 0, 0);
    if (!_window) {
        fprintf(stderr, "ERROR: Cannot initialize GLFW window\n");
        glfwTerminate();
        return;
    }
 
    glfwMakeContextCurrent(_window);
    glfwSetKeyCallback(_window, Window::onKeyboardCb);
    glfwSetMouseButtonCallback(_window, Window::onMouseButtonCb);
    glfwSetCursorPosCallback(_window, Window::onMouseMotionCb);
    glfwSetScrollCallback(_window, Window::onScrollCb);
 
#ifndef APPLE
    if (glewInit() != GLEW_OK)
    {
        std::cout << "Cannot initialize GLEW\n";
        return;
    }
#endif
 
    // Initialize openGL and set default values
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_ALWAYS);
    glEnable(GL_CULL_FACE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  // Alpha blend
    glCullFace(GL_BACK);
 
    background(0, 0, 0);
 
    const float triangle[] =
    {
        -0.5, -0.5, 0, 
        0.5, -0.5, 0,
        0.0, 0.5, 0 
    };
 
    const float square[] =
    {
        -0.5, -0.5, 0, 
        0.5, -0.5, 0,
        0.5, 0.5, 0,
 
        -0.5, -0.5, 0, 
        0.5, 0.5, 0,
        -0.5, 0.5, 0 
    };
 
    // numVerts = numTris + 2 -> Set numTris = 16
    float* circle = new float[3*(numTris+2)]; // numFloats = numVerts * 3 = 36
    circle[0] = circle[1] = circle[2] = 0.0;
    float deltaAngle = 2.0f * 3.1415926535897932384626433832795f / numTris;
    for (int i = 1; i < numTris+2; i++) {
      float angle = (i-1) * deltaAngle;
      circle[i*3+0] = cos(angle);
      circle[i*3+1] = sin(angle);
      circle[i*3+2] = 0;
    }
 
    // default texture
    glEnable(GL_TEXTURE0);
    glActiveTexture(GL_TEXTURE0);
    GLuint texId;
    glGenTextures(1, &texId);
    _textures["default"] = Texture{texId, 1, 1};
    unsigned char defaultTex[4] = { 255,255,255,255 };
    glBindTexture(GL_TEXTURE_2D, texId);
    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1,
      GL_RGBA, GL_UNSIGNED_BYTE, defaultTex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
    GLuint vboId;
    glGenBuffers(1, &vboId);
    glBindBuffer(GL_ARRAY_BUFFER, vboId);
    glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(float), triangle, GL_STATIC_DRAW);
 
    glGenVertexArrays(1, &_triVao);
    glBindVertexArray(_triVao);
    glEnableVertexAttribArray(0); // 0 -> activate sending VertexPositions to the active shader
    glBindBuffer(GL_ARRAY_BUFFER, vboId); // as a habit -> always bind before setting data
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
 
    glGenBuffers(1, &vboId);
    glBindBuffer(GL_ARRAY_BUFFER, vboId);
    glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(float), square, GL_STATIC_DRAW);
 
    glGenVertexArrays(1, &_squareVao);
    glBindVertexArray(_squareVao);
    glEnableVertexAttribArray(0); // 0 -> activate sending VertexPositions to the active shader
    glBindBuffer(GL_ARRAY_BUFFER, vboId); // as a habit -> always bind before setting data
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
 
    glGenBuffers(1, &vboId);
    glBindBuffer(GL_ARRAY_BUFFER, vboId);
    glBufferData(GL_ARRAY_BUFFER, 3*(numTris+2) * sizeof(float), circle, GL_STATIC_DRAW);
 
    glGenVertexArrays(1, &_circleVao);
    glBindVertexArray(_circleVao);
    glEnableVertexAttribArray(0); // 0 -> activate sending VertexPositions to the active shader
    glBindBuffer(GL_ARRAY_BUFFER, vboId); // as a habit -> always bind before setting data
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
    delete[] circle;
 
    GLint result;
    GLuint vshaderId = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vshaderId, 1, vertexShader, NULL);
    glCompileShader(vshaderId);
    glGetShaderiv(vshaderId, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE)
    {
       PrintShaderErrors(vshaderId, "Vertex shader");
    }
 
    GLuint fshaderId = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fshaderId, 1, fragmentShader, NULL);
    glCompileShader(fshaderId);
    glGetShaderiv(fshaderId, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE)
    {
       PrintShaderErrors(fshaderId, "Fragment shader");
    }
 
    GLuint shaderId = glCreateProgram();
    glAttachShader(shaderId, vshaderId);
    glAttachShader(shaderId, fshaderId);
    glLinkProgram(shaderId);
    glGetShaderiv(shaderId, GL_LINK_STATUS, &result);
    if (result == GL_FALSE)
    {
       PrintShaderErrors(shaderId, "Shader link");
    }
 
    glUseProgram(shaderId);
    _colorUniform = glGetUniformLocation(shaderId, "inColor");
    _sizeUniform = glGetUniformLocation(shaderId, "inSize");
    _posUniform = glGetUniformLocation(shaderId, "inPos");
 
    GLuint widthUniform = glGetUniformLocation(shaderId, "inScreenWidth");
    glUniform1f(widthUniform, _windowWidth);
 
    GLuint heightUniform = glGetUniformLocation(shaderId, "inScreenHeight");
    glUniform1f(heightUniform, _windowHeight);
 
    _imageUniform = glGetUniformLocation(shaderId, "inImage");
    glUniform1i(_imageUniform, 0); // texture slot 0
  }
 
  virtual ~Window() {
    glfwTerminate();   
  }
 
  void run() {
    if (!_window) return;  // window wasn't initialized
    setup();
 
    while (!glfwWindowShouldClose(_window)) {
        float time = glfwGetTime();
        _dt = time - _elapsedTime;
        _elapsedTime = time;
 
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        draw();  // user function
        glfwPollEvents();
        glfwSwapBuffers(_window);
    }
  }
 
 protected:
 
 
  void loadSprite(const std::string& name, const std::string& filename) {
 
    int w, h, n;
    unsigned char* data = stbi_load(filename.c_str(), &w, &h, &n, 4);
 
    if (!data) {
      std::cout << "ERROR: Cannot load texture " << filename<< std::endl; 
      return;
    }
 
    glEnable(GL_TEXTURE0);
    glActiveTexture(GL_TEXTURE0);
 
    GLuint texId;
    if (_textures.count(name) == 0) {
      glGenTextures(1, &texId);
      _textures[name] = Texture{texId, w, h};
    } else {
      texId = _textures[name].texId;
    }
 
    glBindTexture(GL_TEXTURE_2D, texId);
    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, w, h);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h,
        GL_RGBA, GL_UNSIGNED_BYTE, data);
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    stbi_image_free(data);
  }
 
  void sprite(const std::string& textureName, float x, float y, float scale = 1) {
    
    assert(_textures.count(textureName) > 0);
 
    Texture& tex = _textures[textureName];
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, tex.texId);
 
    glUniform1i(_imageUniform, 0);
    glUniform3f(_posUniform, x, y, 0);
    glUniform3f(_sizeUniform, tex.width*scale, tex.height*scale, 1);
    glBindVertexArray(_squareVao);
    glDrawArrays(GL_TRIANGLES, 0, 6);
  }
 
  void square(float x, float y, float width, float height) {
    Texture& tex = _textures["default"];
    glBindTexture(GL_TEXTURE_2D, tex.texId);
    
    glUniform3f(_posUniform, x, y, 0);
    glUniform3f(_sizeUniform, width, height, 1);
    glBindVertexArray(_squareVao);
    glDrawArrays(GL_TRIANGLES, 0, 6);
  }
 
  void triangle(int x, int y, float width, float height) {
    Texture& tex = _textures["default"];
    glBindTexture(GL_TEXTURE_2D, tex.texId);
    glUniform3f(_posUniform, x, y, 0);
    glUniform3f(_sizeUniform, width, height, 1);
    glBindVertexArray(_triVao);
    glDrawArrays(GL_TRIANGLES, 0, 3);
  }
 
  void circle(int x, int y, float diameter) {
    ellipsoid(x, y, diameter, diameter);
  }
 
  void ellipsoid(int x, int y, float width, float height) {
    Texture& tex = _textures["default"];
    glBindTexture(GL_TEXTURE_2D, tex.texId);
    glUniform3f(_posUniform, x, y, 0);
    glUniform3f(_sizeUniform, width, height, 1);
    glBindVertexArray(_circleVao);
    glDrawArrays(GL_TRIANGLE_FAN, 0, numTris+2);
  }
 
  void color(float r, float g, float b, float a = 1.0f) {
    glUniform4f(_colorUniform, r, g, b, a);
  }
 
 
 
 
  virtual void setup() {}
 
  virtual void draw() {}
 
  virtual void mouseMotion(int x, int y, int dx, int dy) {}
 
  virtual void mouseDown(int button, int mods) {}
 
  virtual void mouseUp(int button, int mods) {}
 
  virtual void scroll(float dx, float dy) {}
 
  virtual void keyUp(int key, int mods) {}
 
  virtual void keyDown(int key, int mods) {}
 
 
  bool keyIsDown(int key) const {
    int state = glfwGetKey(_window, key);
    return (state == GLFW_PRESS);
  }
 
  bool mouseIsDown(int button) const {
    int state = glfwGetMouseButton(_window, button);
    return (state == GLFW_PRESS);
  }
 
  float mouseX() const {
    double xpos, ypos;
    glfwGetCursorPos(_window, &xpos, &ypos);
    return static_cast<float>(xpos);
  }
 
  float mouseY() const {
    double xpos, ypos;
    glfwGetCursorPos(_window, &xpos, &ypos);
    return static_cast<float>(ypos);
  }
 
  float dt() const {
    return _dt;
  }
 
  float elapsedTime() const {
    return _elapsedTime;
  }
 
  float height() const {
    return static_cast<float>(_windowHeight);
  }
 
  float width() const {
    return static_cast<float>(_windowWidth);
  }
 
  void noLoop() {
    glfwSetWindowShouldClose(_window, GL_TRUE);
  }
 
  void background(float r, float g, float b) {
    glClearColor(r, g, b, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  }
 
 private:
  static void onScrollCb(GLFWwindow* w, double xoffset, double yoffset) {
    theInstance->scroll(
      static_cast<float>(xoffset),
      static_cast<float>(yoffset));
  }
  static void onMouseMotionCb(GLFWwindow* w, double x, double y) {
    theInstance->onMouseMotion(static_cast<int>(x), static_cast<int>(y));
  }
 
  static void onMouseButtonCb(GLFWwindow* w, int button, int action, int mods) {
    theInstance->onMouseButton(button, action, mods);
  }
 
  static void onKeyboardCb(GLFWwindow* w, int key, int code, int action, int mods) {
    theInstance->onKeyboard(key, code, action, mods);
  }
 
  void onMouseMotion(int x, int y) {
    int dx = mouseX() - _lastx;
    int dy = mouseY() - _lasty;
    mouseMotion(x, height()-y, dx, -dy);  // user hook
  }
 
  void onMouseButton(int button, int action, int mods) {
    double xpos, ypos;
    glfwGetCursorPos(_window, &xpos, &ypos);
 
    if (action == GLFW_PRESS) {
      _lastx = xpos;
      _lasty = ypos;
      mouseDown(button, mods);
    } else if (action == GLFW_RELEASE) {
      mouseUp(button, mods);
    }
 
    onMouseMotion(static_cast<float>(xpos), static_cast<float>(ypos));
  }
 
  void onKeyboard(int key, int scancode, int action, int mods) {
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
      glfwSetWindowShouldClose(_window, GL_TRUE);
    }
 
    if (action == GLFW_PRESS) {
      keyDown(key, mods);
    } else if (action == GLFW_RELEASE) {
      keyUp(key, mods);
    }
  }
   
 private:
  int _windowWidth, _windowHeight;
  float _elapsedTime;
  float _dt;
  float _lastx, _lasty;
  struct GLFWwindow* _window = 0;
  GLuint _triVao, _squareVao, _circleVao;
  GLuint _colorUniform, _sizeUniform, _posUniform, _imageUniform;
  const int numTris = 16; // for circles
 
  // textures
  struct Texture {
    GLuint texId;
    int width;
    int height;
  };
  std::map<std::string, Texture> _textures;
 
 protected:
  inline GLFWwindow* window() const { return _window; }
};
 
}  // namespace tinygl
 
#endif