Added BlendEquation and BlendFunc to RenderState, and cleaned it up A LOT

include/Engine/Rendering/RenderState.h

@@ -1,6 +1,7 @@
 #ifndef RenderState_h__
 #define RenderState_h__
 
+#include <functional>
 #include "../Common.h"
 #include "../OpenGL.h"
 #include "../GLM.h"
@@ -8,16 +9,19 @@
 class RenderState 
 {
 public:
-    RenderState();
+    RenderState() = default;
     ~RenderState();
-    bool Enable(GLenum GLEnable);
+
-    bool CullFace(GLenum GlFaceToCull);
+    bool Enable(GLenum cap);
+    bool Disable(GLenum cap);
+    bool CullFace(GLenum mode);
     bool ClearColor(glm::vec4 color);
     bool Clear(GLbitfield mask);
-    bool BindBuffer(GLint buffer);
+    bool BindFramebuffer(GLint framebuffer);
+    bool BlendEquation(GLenum mode);
+    bool BlendFunc(GLenum sfactor, GLenum dfactor);
+
 private:
-    std::vector<GLenum> m_Enables;
+    std::vector<std::function<void(void)>> m_ResetFunctions;
-    float m_preClearColor[4];
-    int m_preBuffer;
 };
 #endif

src/Engine/Rendering/DrawScenePassState.cpp

@@ -4,7 +4,7 @@
 DrawScenePassState::DrawScenePassState()
 {
     GLERROR("---");
-    BindBuffer(0);
+    BindFramebuffer(0);
     GLERROR("---");
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);

src/Engine/Rendering/PickingPassState.cpp

@@ -4,7 +4,7 @@
 PickingPassState::PickingPassState(GLuint frameBuffer)
 {
     GLERROR("---2");
-    BindBuffer(frameBuffer);
+    BindFramebuffer(frameBuffer);
     GLERROR("---3");
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);

src/Engine/Rendering/RenderState.cpp

@@ -1,110 +1,99 @@
 #include "Rendering/RenderState.h"
 
-RenderState::RenderState()
+bool RenderState::Enable(GLenum cap)
 {
-
+    if (glIsEnabled(cap)) {
-}
-
-bool RenderState::Enable(GLenum GLEnable)
-{
-    if(glIsEnabled(GLEnable))
-    {
         return false;
     }
-    m_Enables.push_back(GLEnable);
+    m_ResetFunctions.push_back(std::bind(glDisable, cap));
-    glEnable(GLEnable);
+    glEnable(cap);
-    if (GLERROR("RenderState::Enable"))
+    return !GLERROR("RenderState::Enable");
-    {
-        return false;
-    }
-    return true;
 }
 
-bool RenderState::CullFace(GLenum GLCullFace)
+bool RenderState::Disable(GLenum cap)
 {
-    if(!glIsEnabled(GL_CULL_FACE))
+    if (!glIsEnabled(cap)) {
-    {
+        return false;
+    }
+    m_ResetFunctions.push_back(std::bind(glEnable, cap));
+    glDisable(cap);
+    return !GLERROR("RenderState::Disable");
+}
+
+bool RenderState::CullFace(GLenum mode)
+{
+    if (!glIsEnabled(GL_CULL_FACE)) {
         LOG_ERROR("Setting GL_CULL_FACE without enabling it.");
         return false;
     }
     
-    GLint a;
+    GLint original;
-    glGetIntegerv(GL_CULL_FACE_MODE, &a);
+    glGetIntegerv(GL_CULL_FACE_MODE, &original);
-    if(a != GL_BACK)
+    m_ResetFunctions.push_back(std::bind(glCullFace, original));
-    {
+    glCullFace(mode);
-        //LOG_INFO("Setting Cullface to back, unessesary since this is already default.");
+    return !GLERROR("RenderState::CullFace");
-        glCullFace(GLCullFace);
-    }
-    if (GLERROR("RenderState::CullFace"))
-    {
-        return false;
-    }
-    return true;
 }
 
 bool RenderState::ClearColor(glm::vec4 color)
 {
-    glGetFloatv(GL_COLOR_CLEAR_VALUE, &m_preClearColor[0]);
+    GLfloat original[4];
+    glGetFloatv(GL_COLOR_CLEAR_VALUE, &original[0]);
+    m_ResetFunctions.push_back(std::bind(glClearColor, original[0], original[1], original[2], original[3]));
     glClearColor(color.r, color.g, color.b, color.a);
-    if (GLERROR("RenderState::ClearColor")) {
+    return !GLERROR("RenderState::ClearColor");
-        return false;
-    }
-    return true;
 }
 
 bool RenderState::Clear(GLbitfield mask)
 {
     glClear(mask);
-    if (GLERROR("RenderState::Clear")) {
+    return !GLERROR("RenderState::Clear");
-        return false;
-    }
-    return true;
 }
 
-bool RenderState::BindBuffer(GLint buffer)
+bool RenderState::BindFramebuffer(GLint framebuffer)
 {
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_preBuffer);
+    GLint originalRead;
-    if (buffer == m_preBuffer)
+    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &originalRead);
-    {
+    GLint originalDraw;
-        return true;
+    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &originalDraw);
-    }
+    m_ResetFunctions.push_back([originalRead, originalDraw]() {
-    glBindFramebuffer(GL_FRAMEBUFFER, buffer);
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, originalRead); 
-    if (GLERROR("RenderState::BindBuffer"))
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, originalDraw); 
-    {
+    });
-        printf("BufferID: %i\npreBufferID: %i\n", buffer, m_preBuffer);
+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-        return false;
+    return !GLERROR("RenderState::BindBuffer");
-    }
+}
-    return true;
+
+
+bool RenderState::BlendEquation(GLenum mode)
+{
+    GLint originalRGB;
+    glGetIntegerv(GL_BLEND_EQUATION_RGB, &originalRGB);
+    GLint originalAlpha;
+    glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &originalAlpha);
+    m_ResetFunctions.push_back(std::bind(glBlendEquationSeparate, originalRGB, originalAlpha));
+    glBlendEquation(mode);
+    return !GLERROR("RenderState::BlendEquation");
+}
+
+bool RenderState::BlendFunc(GLenum sfactor, GLenum dfactor)
+{
+    GLint originalSrcRGB;
+    glGetIntegerv(GL_BLEND_SRC_RGB, &originalSrcRGB);
+    GLint originalSrcAlpha;
+    glGetIntegerv(GL_BLEND_SRC_ALPHA, &originalSrcAlpha);
+    GLint originalDestRGB;
+    glGetIntegerv(GL_BLEND_DST_RGB, &originalDestRGB);
+    GLint originalDestAlpha;
+    glGetIntegerv(GL_BLEND_DST_ALPHA, &originalDestAlpha);
+    m_ResetFunctions.push_back(std::bind(glBlendFuncSeparate, originalSrcRGB, originalSrcAlpha, originalDestRGB, originalDestAlpha));
+    glBlendFunc(sfactor, dfactor);
+    return !GLERROR("RenderState::BlendFunc");
 }
 
 RenderState::~RenderState()
 {
-    GLERROR("RenderState::~RenderState Pre");
+    for (auto& f : m_ResetFunctions) {
-    GLint n_buffer = -1;
+        f();
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &n_buffer);
-
-    //Set cullface to default
-    if (glIsEnabled(GL_CULL_FACE)) {
-        glCullFace(GL_BACK);
     }
-    GLERROR("RenderState::~RenderState glCullFace");
-
-    //Set color to default
-    glClearColor(m_preClearColor[0], m_preClearColor[1], m_preClearColor[2], m_preClearColor[3]);
-    GLERROR("RenderState::~RenderState glClearColor");
-
-    //Disable Enables
-    for (auto i : m_Enables)
-    {
-        glDisable(i);
-    }
-    GLERROR("RenderState::~RenderState glDisable");
-
-    if(m_preBuffer != 0)
-    {
-        glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    }
-    m_Enables.clear();
-    GLERROR("RenderState::~RenderState glBindFramebuffer");
 }