textures need a format, framebuffers

Main.cpp

@@ -20,6 +20,7 @@
 #include "tests/ClockTests.h"
 #include "tests/PNGReaderTests.h"
 #include "tests/BufferTests.h"
+#include "wrapper/Framebuffer.h"
 
 int main(int argAmount, char** args) {
     if(argAmount < 2) {

meson.build

@@ -41,7 +41,8 @@ sources = ['Main.cpp',
     'wrapper/Window.cpp',
     'wrapper/WindowOptions.cpp',
     'input/Button.cpp',
-    'input/Buttons.cpp']
+    'input/Buttons.cpp',
+    'wrapper/TextureFormat.cpp']
 
 glewDep = dependency('glew')
 glfwDep = dependency('glfw3')

wrapper/Framebuffer.h

@@ -0,0 +1,109 @@
+#ifndef FRAMEBUFFER_H
+#define FRAMEBUFFER_H
+
+#include <iostream>
+
+#include "utils/List.h"
+#include "wrapper/Texture.h"
+#include "utils/Size.h"
+
+template<int N>
+class Framebuffer final {
+    List<Texture, N> textures;
+    GLuint buffer;
+
+public:
+
+    template<typename... Args>
+    Framebuffer(const TextureFormat& a, Args&&... args) : buffer(0) {
+        const int size = sizeof...(args) + 1;
+        TextureFormat init[size] = {a, args...};
+        static_assert(N == size, "framebuffer size and amount of arguments do not match");
+        for(int i = 0; i < N; i++) {
+            textures.add(init[i]);
+            textures[i].setClampWrap();
+        }
+    }
+
+    ~Framebuffer() {
+        glDeleteFramebuffers(1, &buffer);
+    }
+
+    Framebuffer(const Framebuffer&) = delete;
+    Framebuffer(Framebuffer&&) = delete;
+    Framebuffer& operator=(const Framebuffer&) = delete;
+    Framebuffer& operator=(Framebuffer&&) = delete;
+
+    bool init(const Size& size) {
+        glGenFramebuffers(1, &buffer);
+        glBindFramebuffer(GL_FRAMEBUFFER, buffer);
+
+        List<GLenum, N> attachments;
+        for(Texture& t : textures) {
+            t.setData(size.width, size.height);
+            if(t.format.depth) {
+                glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, t.texture, 0);
+            } else {
+                GLenum c = GL_COLOR_ATTACHMENT0 + attachments.getLength();
+                glFramebufferTexture2D(GL_FRAMEBUFFER, c, GL_TEXTURE_2D, t.texture, 0);
+                attachments.add(c);
+            }
+        }
+        glDrawBuffers(attachments.getLength(), attachments.begin());
+
+        return hasError();
+    }
+
+    void bindAndClear() {
+        glBindFramebuffer(GL_FRAMEBUFFER, buffer);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    }
+
+    void bindTextureTo(int index, int textureUnit) const {
+        textures[index].bindTo(textureUnit);
+    }
+
+    void resize(const Size& size) const {
+        for(Texture& t : textures) {
+            t.setData(size.width, size.height);
+        }
+    }
+
+private:
+
+    bool hasError() const {
+        GLenum error = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+        if(error == GL_FRAMEBUFFER_COMPLETE) {
+            return false;
+        }
+        switch(error) {
+            case GL_FRAMEBUFFER_UNDEFINED:
+                std::cout << "undefined framebuffer\n";
+                return true;
+            case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+                std::cout << "incomplete framebuffer attachment\n";
+                return true;
+            case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+                std::cout << "incomplete missing framebuffer attachment\n";
+                return true;
+            case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
+                std::cout << "incomplete framebuffer draw buffer\n";
+                return true;
+            case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
+                std::cout << "incomplete framebuffer read buffer\n";
+                return true;
+            case GL_FRAMEBUFFER_UNSUPPORTED:
+                std::cout << "unsupported framebuffer\n";
+                return true;
+            case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+                std::cout << "incomplete framebuffer multisample\n";
+                return true;
+            case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
+                std::cout << "incomplete framebuffer layer targets\n";
+                return true;
+        }
+        return "unknown error";
+    }
+};
+
+#endif

wrapper/Texture.cpp

@@ -1,47 +1,53 @@
 #include "wrapper/Texture.h"
 
-Texture::Texture(Mode mode) : texture(0) {
+Texture::Texture(const TextureFormat& format) : format(format), texture(0) {
     glGenTextures(1, &texture);
-    glBindTexture(GL_TEXTURE_2D, texture);
-    switch(mode) {
-        case NEAREST:
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-            break;
-        case LINEAR:
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-            break;
-    }
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    setNearestFilter();
+    setRepeatWrap();
 }
 
 Texture::~Texture() {
     glDeleteTextures(1, &texture);
 }
 
-void Texture::setColorData(int width, int height, const Color4* data) {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+void Texture::setFilter(GLint param) {
+    bind();
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, param);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, param);
 }
 
-void Texture::setColorData(int width, int height, const Color3* data) {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
+void Texture::setNearestFilter() {
+    setFilter(GL_NEAREST);
 }
 
-void Texture::setColorData(int width, int height, const Color2* data) {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RG, width, height, 0, GL_RG, GL_UNSIGNED_BYTE, data);
+void Texture::setLinearFilter() {
+    setFilter(GL_LINEAR);
 }
 
-void Texture::setColorData(int width, int height, const Color1* data) {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, data);
+void Texture::setWrap(GLint param) {
+    bind();
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, param);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, param);
 }
 
-void Texture::setRGBFloatData(int width, int height, const float* data) {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, height, 0, GL_RGB, GL_FLOAT, data);
+void Texture::setRepeatWrap() {
+    setWrap(GL_REPEAT);
 }
 
-void Texture::bind(int index) const {
-    glActiveTexture(GL_TEXTURE0 + index);
+void Texture::setClampWrap() {
+    setWrap(GL_CLAMP_TO_EDGE);
+}
+
+void Texture::setData(int width, int height, const void* data) {
     glBindTexture(GL_TEXTURE_2D, texture);
+    glTexImage2D(GL_TEXTURE_2D, 0, format.internalformat, width, height, 0, format.format, format.type, data);
 }
+
+void Texture::bind() const {
+    glBindTexture(GL_TEXTURE_2D, texture);
+}
+
+void Texture::bindTo(int index) const {
+    glActiveTexture(GL_TEXTURE0 + index);
+    bind();
+}

wrapper/Texture.h

@@ -3,40 +3,35 @@
 
 #include <GL/glew.h>
 
-#include "utils/Color.h"
+#include "wrapper/TextureFormat.h"
 
 class Texture final {
+    const TextureFormat format;
     GLuint texture;
+    
+    template<int N>
+    friend class Framebuffer;
 
 public:
-
-    enum Mode {
-        NEAREST, LINEAR
-    };
-
-    Texture(Mode mode = NEAREST);
+    Texture(const TextureFormat& format);
     ~Texture();
     Texture(const Texture& other) = delete;
     Texture(Texture&& other) = delete;
     Texture& operator=(const Texture& other) = delete;
     Texture& operator=(Texture&& other) = delete;
 
-    void setColorData(int width, int height, const Color4* data);
-    void setColorData(int width, int height, const Color3* data);
-    void setColorData(int width, int height, const Color2* data);
-    void setColorData(int width, int height, const Color1* data);
-
-    void setRGBFloatData(int width, int height, const float* data);
-
-    void bind(int index = 0) const;
+    void setNearestFilter();
+    void setLinearFilter();
+    void setRepeatWrap();
+    void setClampWrap();
+    void setData(int width, int height, const void* data = nullptr);
 
+    void bindTo(int index = 0) const;
+    
 private:
-
-    template<int N>
-    void setColorData(int width, int height, int mode, const Color<N>* data) {
-        glBindTexture(GL_TEXTURE_2D, texture);
-        glTexImage2D(GL_TEXTURE_2D, 0, mode, width, height, 0, mode, GL_UNSIGNED_BYTE, data);
-    }
+    void setFilter(GLint param);
+    void setWrap(GLint param);
+    void bind() const;
 };
 
 #endif

wrapper/TextureFormat.cpp

@@ -0,0 +1,61 @@
+#include "wrapper/TextureFormat.h"
+
+TextureFormat::TextureFormat(GLint internalformat, GLenum format, GLenum type, bool depth) :
+internalformat(internalformat), format(format), type(type), depth(depth) {
+}
+
+TextureFormat TextureFormat::color1() {
+    return TextureFormat(GL_RED, GL_RED, GL_UNSIGNED_BYTE);
+}
+
+TextureFormat TextureFormat::color2() {
+    return TextureFormat(GL_RG, GL_RG, GL_UNSIGNED_BYTE);
+}
+
+TextureFormat TextureFormat::color3() {
+    return TextureFormat(GL_RGB, GL_RGB, GL_UNSIGNED_BYTE);
+}
+
+TextureFormat TextureFormat::color4() {
+    return TextureFormat(GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE);
+}
+
+TextureFormat TextureFormat::float16() {
+    return TextureFormat(GL_R16F, GL_RED, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::float32() {
+    return TextureFormat(GL_R32F, GL_RED, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::float16Vector2() {
+    return TextureFormat(GL_RG16F, GL_RG, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::float16Vector3() {
+    return TextureFormat(GL_RGB16F, GL_RGB, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::float16Vector4() {
+    return TextureFormat(GL_RGBA16F, GL_RGBA, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::float32Vector2() {
+    return TextureFormat(GL_RG32F, GL_RG, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::float32Vector3() {
+    return TextureFormat(GL_RGB32F, GL_RGB, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::float32Vector4() {
+    return TextureFormat(GL_RGBA32F, GL_RGBA, GL_FLOAT);
+}
+
+TextureFormat TextureFormat::depth16() {
+    return TextureFormat(GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_FLOAT, true);
+}
+
+TextureFormat TextureFormat::depth32() {
+    return TextureFormat(GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_FLOAT, true);
+}

wrapper/TextureFormat.h

@@ -0,0 +1,35 @@
+#ifndef TEXTUREDATA_H
+#define TEXTUREDATA_H
+
+#include <GL/glew.h>
+
+struct TextureFormat final {
+    const GLint internalformat;
+    const GLenum format;
+    const GLenum type;
+    const bool depth;
+
+    static TextureFormat color1();
+    static TextureFormat color2();
+    static TextureFormat color3();
+    static TextureFormat color4();
+
+    static TextureFormat float16();
+    static TextureFormat float32();
+
+    static TextureFormat float16Vector2();
+    static TextureFormat float16Vector3();
+    static TextureFormat float16Vector4();
+
+    static TextureFormat float32Vector2();
+    static TextureFormat float32Vector3();
+    static TextureFormat float32Vector4();
+
+    static TextureFormat depth16();
+    static TextureFormat depth32();
+
+private:
+    TextureFormat(GLint internalformat, GLenum format, GLenum type, bool depth = false);
+};
+
+#endif