+ added glclasses for texture, fbo & rbo

game/glclasses.cpp

@@ -6,136 +6,182 @@
 #include <sstream>
 
 namespace endofthejedi {
-    VAO::VAO() { glGenVertexArrays(1, &m_name); }
+VAO::VAO() { glGenVertexArrays(1, &m_name); }
 
-    VAO::~VAO() { glDeleteVertexArrays(1, &m_name); }
+VAO::~VAO() { glDeleteVertexArrays(1, &m_name); }
 
-    void VAO::bind() { glBindVertexArray(m_name); }
+void VAO::bind() { glBindVertexArray(m_name); }
-    void VAO::unbind() { glBindVertexArray(0); }
+void VAO::unbind() { glBindVertexArray(0); }
 
-    void VAO::fill(GLuint index, GLint size, GLenum type,
+void VAO::fill(GLuint index, GLint size, GLenum type, GLboolean normalized,
-            GLboolean normalized, GLsizei stride,
+               GLsizei stride, const GLvoid *pointer) {
-            const GLvoid *pointer)
+    glEnableVertexAttribArray(index);
-    {
+    glVertexAttribPointer(index, size, type, normalized, stride, pointer);
-        glEnableVertexAttribArray(index);
+}
-        glVertexAttribPointer(index, size, type, normalized, stride, pointer);
+
+Shader::Shader() : m_program(0) {}
+
+Shader::~Shader() {}
+
+void Shader::init() { m_program = glCreateProgram(); }
+
+bool Shader::check() {
+    GLint len = 0;
+    GLint result = 0;
+
+    glGetProgramiv(m_program, GL_LINK_STATUS, &result);
+    glGetProgramiv(m_program, GL_INFO_LOG_LENGTH, &len);
+
+    if (result == GL_FALSE) {
+        std::cout << "getting error log:" << std::endl;
+        char *error = (char *)malloc(len + 1);
+        glGetProgramInfoLog(m_program, len, NULL, error);
+        std::string str(error);
+        std::cout << str << std::endl;
+    }
+    // std::cout << "checked program" << std::endl;
+
+    return (bool)result;
+}
+
+bool Shader::checkShader(GLuint shader) {
+    GLint len = 0;
+    GLint result = 0;
+
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
+
+    if (result == GL_FALSE) {
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
+        char *error = (char *)malloc(len + 1);
+        glGetShaderInfoLog(shader, len, NULL, error);
+        std::string str(error, error + len);
+        std::cout << str << std::endl;
     }
 
-    Shader::Shader() : m_program(0) { }
+    // std::cout << "checked shader" << std::endl;
 
-    Shader::~Shader() {}
+    return result != GL_FALSE;
+}
 
-    void Shader::init() { m_program = glCreateProgram(); }
+void Shader::bind() {
+    if (m_program == 0) {
+        std::cerr << "error: invalid to bind invalid program (0)! "
+                     "use unbind() if that was your purpose!" << std::endl;
 
-    bool Shader::check() {
+        exit(-1);
-        GLint len = 0;
+        return;
-        GLint result = 0;
-
-        glGetProgramiv(m_program, GL_LINK_STATUS, &result);
-        glGetProgramiv(m_program, GL_INFO_LOG_LENGTH, &len);
-
-        if (result == GL_FALSE) {
-            std::cout<<"getting error log:" << std::endl;
-            char *error = (char *)malloc(len+1);
-            glGetProgramInfoLog(m_program, len, NULL, error);
-            std::string str(error);
-            std::cout << str << std::endl;
-        }
-        //std::cout << "checked program" << std::endl;
-
-        return (bool)result;
     }
 
-    bool Shader::checkShader(GLuint shader) {
+    glUseProgram(m_program);
-        GLint len = 0;
+}
-        GLint result = 0;
 
-        glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
+GLuint Shader::program() { return m_program; }
 
-        if (result == GL_FALSE) {
+void Shader::unbind() { glUseProgram(0); }
-            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
-            char *error = (char *)malloc(len+1);
-            glGetShaderInfoLog(shader, len, NULL, error);
-            std::string str(error, error + len);
-            std::cout << str << std::endl;
-        }
 
-        //std::cout << "checked shader" << std::endl;
+void Shader::load(const std::string &data, GLenum shadertype) {
-
+    if (m_program == 0) {
-        return result != GL_FALSE;
+        std::cout << "[shader] error: shader program is invalid (0)!"
+                  << std::endl;
+        exit(-1);
+        return;
     }
 
-    void Shader::bind()
+    GLuint shader = glCreateShader(shadertype);
-    {
-        if (m_program == 0) {
-            std::cerr << "error: invalid to bind invalid program (0)! "
-                "use unbind() if that was your purpose!" << std::endl;
 
-            exit(-1);
+    const char *shaderdata = data.c_str();
-            return;
+    glShaderSource(shader, 1, &shaderdata, NULL);
-        }
+    glCompileShader(shader);
+    checkShader(shader);
 
-        glUseProgram(m_program);
+    glAttachShader(m_program, shader);
-    }
+    glLinkProgram(m_program);
+    check();
 
-    GLuint Shader::program() { return m_program; }
+    glDeleteShader(shader);
+}
 
-    void Shader::unbind() { glUseProgram(0); }
+void Shader::loadFile(const std::string &path, GLenum shadertype) {
-
-    void Shader::load(const std::string &data, GLenum shadertype) {
-        if (m_program == 0) {
-            std::cout<<"[shader] error: shader program is invalid (0)!" << std::endl;
-            exit(-1);
-            return;
-        }
-
-        GLuint shader = glCreateShader(shadertype);
-
-        const char *shaderdata = data.c_str();
-        glShaderSource(shader, 1, &shaderdata, NULL);
-        glCompileShader(shader);
-        checkShader(shader);
-
-        glAttachShader(m_program, shader);
-        glLinkProgram(m_program);
-        check();
-
-        glDeleteShader(shader);
-    }
-
-  void Shader::loadFile(const std::string &path, GLenum shadertype) {
     std::string content;
     std::ifstream fileStream(path, std::ios::in);
 
-    if(!fileStream.is_open()) {
+    if (!fileStream.is_open()) {
-        std::cerr << "Could not read file " << path << ". File does not exist." << std::endl;
+        std::cerr << "Could not read file " << path << ". File does not exist."
+                  << std::endl;
         return;
     }
 
     std::string line = "";
-    while(!fileStream.eof()) {
+    while (!fileStream.eof()) {
         std::getline(fileStream, line);
         content.append(line + "\n");
     }
 
     fileStream.close();
     load(content, shadertype);
-  }
-
-    GLuint Shader::location(const std::string &name) {
-        return glGetUniformLocation(m_program, name.c_str());
-    }
 }
 
-void printGlError(GLenum err)
+GLuint Shader::location(const std::string &name) {
-{
+    return glGetUniformLocation(m_program, name.c_str());
+}
+
+Texture::Texture() { glGenTextures(1, &m_name); }
+
+Texture::~Texture() { glDeleteTextures(1, &m_name); }
+
+void Texture::bind() { glBindTexture(GL_TEXTURE_2D, m_name); }
+
+void Texture::unbind() { glBindTexture(GL_TEXTURE_2D, 0); }
+
+void Texture::fill(GLenum target, GLint level, GLint internalFormat,
+                   GLsizei width, GLsizei height, GLint border, GLenum format,
+                   GLenum type, const GLvoid *data) {
+    bind();
+    glTexImage2D(target, level, internalFormat, width, height, border, format,
+                 type, data);
+}
+GLuint Texture::getName() { return m_name; }
+
+Framebuffer::Framebuffer() { glGenFramebuffers(1, &m_name); }
+
+Framebuffer::~Framebuffer() { glDeleteFramebuffers(1, &m_name); }
+
+void Framebuffer::bind() { glBindFramebuffer(GL_FRAMEBUFFER, m_name); }
+
+void Framebuffer::unbind() { glBindFramebuffer(GL_FRAMEBUFFER, 0); }
+
+void Framebuffer::attachRenderbuffer(GLenum attachment, GLuint rbo) {
+    bind();
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, attachment, GL_RENDERBUFFER, rbo);
+}
+
+void Framebuffer::attachTexture(GLenum attachment, GLuint tex) {
+    bind();
+    glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_2D, tex, 0);
+}
+
+Renderbuffer::Renderbuffer() { glGenRenderbuffers(1, &m_name); }
+
+Renderbuffer::~Renderbuffer() { glDeleteRenderbuffers(1, &m_name); }
+
+void Renderbuffer::bind() { glBindRenderbuffer(GL_RENDERBUFFER, m_name); }
+
+void Renderbuffer::unbind() { glBindRenderbuffer(GL_RENDERBUFFER, 0); }
+
+void Renderbuffer::create(GLenum internalformat, GLsizei width,
+                          GLsizei height) {
+    bind();
+    glRenderbufferStorage(GL_RENDERBUFFER, internalformat, width, height);
+}
+}
+
+void printGlError(GLenum err) {
     if (err != GL_NO_ERROR) {
         std::cout << "opengl error is: " << stringFromGlError(err) << std::endl;
     }
 }
 
-void discardLastGlError(bool print)
+void discardLastGlError(bool print) {
-{
     GLenum err = glGetError();
     if (print) {
         printGlError(err);
@@ -143,8 +189,7 @@ void discardLastGlError(bool print)
 }
 
 // return false if there's an error
-bool checkAndPrintGlError()
+bool checkAndPrintGlError() {
-{
     GLenum err = glGetError();
 
     printGlError(err);
@@ -152,15 +197,25 @@ bool checkAndPrintGlError()
     return true;
 }
 
-const char *stringFromGlError(GLenum err)
+const char *stringFromGlError(GLenum err) {
-{
+    switch (err) {
-    switch(err) {
+    case GL_INVALID_ENUM:
-        case GL_INVALID_ENUM:                  return "GL_INVALID_ENUM"; break;
+        return "GL_INVALID_ENUM";
-        case GL_INVALID_VALUE:                 return "GL_INVALID_VALUE"; break;
+        break;
-        case GL_INVALID_OPERATION:             return "GL_INVALID_OPERATION"; break;
+    case GL_INVALID_VALUE:
-        case GL_OUT_OF_MEMORY:                 return "GL_OUT_OF_MEMORY"; break;
+        return "GL_INVALID_VALUE";
-        case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION"; break;
+        break;
-        default:                               return "<unknown>"; break;
+    case GL_INVALID_OPERATION:
+        return "GL_INVALID_OPERATION";
+        break;
+    case GL_OUT_OF_MEMORY:
+        return "GL_OUT_OF_MEMORY";
+        break;
+    case GL_INVALID_FRAMEBUFFER_OPERATION:
+        return "GL_INVALID_FRAMEBUFFER_OPERATION";
+        break;
+    default:
+        return "<unknown>";
+        break;
     }
 }
-

game/glclasses.hpp

@@ -57,10 +57,53 @@ class Shader {
     void bind();
     void unbind();
     void load(const std::string &data, GLenum shadertype);
-  void loadFile(const std::string& data, GLenum shadertype);
+    void loadFile(const std::string &data, GLenum shadertype);
     GLuint location(const std::string &name);
     GLuint program();
 };
+
+class Texture {
+  private:
+    GLuint m_name;
+
+  protected:
+  public:
+    Texture();
+    ~Texture();
+    void bind();
+    void unbind();
+    void fill(GLenum target, GLint level, GLint internalFormat, GLsizei width,
+              GLsizei height, GLint border, GLenum format, GLenum type,
+              const GLvoid *data);
+    GLuint getName();
+};
+
+class Framebuffer {
+  private:
+    GLuint m_name;
+
+  protected:
+  public:
+    Framebuffer();
+    ~Framebuffer();
+    void bind();
+    void unbind();
+    void attachRenderbuffer(GLenum attachment, GLuint rbo);
+    void attachTexture(GLenum attachment, GLuint tex);
+};
+
+class Renderbuffer {
+  private:
+    GLuint m_name;
+
+  protected:
+  public:
+    Renderbuffer();
+    ~Renderbuffer();
+    void bind();
+    void unbind();
+    void create(GLenum internalformat, GLsizei width, GLsizei height);
+};
 }
 
 #define TBufferObject_(pre, post)                                              \
@@ -94,7 +137,7 @@ TBufferObject(void, unmap)() {
     // todo
 }
 
-void discardLastGlError(bool print=false);
+void discardLastGlError(bool print = false);
 
 // return false if there's an error
 bool checkAndPrintGlError();
@@ -102,4 +145,3 @@ bool checkAndPrintGlError();
 void printGlError(GLenum err);
 
 const char *stringFromGlError(GLenum err);
-