Merge remote-tracking branch 'origin/master' into Forward+

# Conflicts:
#	include/Engine/Rendering/Renderer.h
#	src/Engine/Rendering/RenderState.cpp
#	src/Engine/Rendering/Renderer.cpp

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/ImGuiRenderPass.cpp

@@ -0,0 +1,307 @@
+#include "Rendering/ImGuiRenderPass.h"
+
+ImGuiRenderPass::ImGuiRenderPass(IRenderer* renderer, EventBroker* eventBroker)
+    : m_Renderer(renderer)
+    , m_EventBroker(eventBroker)
+{
+    g_Window = renderer->Window();
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;                         // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
+    io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT;
+    io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
+    io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
+    io.KeyMap[ImGuiKey_DownArrow] = GLFW_KEY_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = GLFW_KEY_PAGE_UP;
+    io.KeyMap[ImGuiKey_PageDown] = GLFW_KEY_PAGE_DOWN;
+    io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME;
+    io.KeyMap[ImGuiKey_End] = GLFW_KEY_END;
+    io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE;
+    io.KeyMap[ImGuiKey_Backspace] = GLFW_KEY_BACKSPACE;
+    io.KeyMap[ImGuiKey_Enter] = GLFW_KEY_ENTER;
+    io.KeyMap[ImGuiKey_Escape] = GLFW_KEY_ESCAPE;
+    io.KeyMap[ImGuiKey_A] = GLFW_KEY_A;
+    io.KeyMap[ImGuiKey_C] = GLFW_KEY_C;
+    io.KeyMap[ImGuiKey_V] = GLFW_KEY_V;
+    io.KeyMap[ImGuiKey_X] = GLFW_KEY_X;
+    io.KeyMap[ImGuiKey_Y] = GLFW_KEY_Y;
+    io.KeyMap[ImGuiKey_Z] = GLFW_KEY_Z;
+
+    ImGuiStyle& style = ImGui::GetStyle();
+    style.Alpha = 1.f;
+    style.WindowPadding = ImVec2(8.f, 7.f);
+    style.WindowRounding = 4.f;
+    style.ChildWindowRounding = 0.f;
+    style.FramePadding = ImVec2(4.f, 2.f);
+    style.FrameRounding = 2.f;
+    style.ItemSpacing = ImVec2(6.f, 2.f);
+    style.ItemInnerSpacing = ImVec2(3.f, 4.f);
+    style.IndentSpacing = 16.f;
+    style.ScrollbarSize = 12;
+    style.ScrollbarRounding = 2.f;
+    style.GrabMinSize = 13.f;
+    style.GrabRounding = 3.f;
+
+    createDeviceObjects();
+    
+    EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &ImGuiRenderPass::OnMousePress);
+    EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &ImGuiRenderPass::OnMouseRelease);
+    EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &ImGuiRenderPass::OnMouseMove);
+    EVENT_SUBSCRIBE_MEMBER(m_EMouseScroll, &ImGuiRenderPass::OnMouseScroll);
+    EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &ImGuiRenderPass::OnKeyDown);
+    EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &ImGuiRenderPass::OnKeyUp);
+    EVENT_SUBSCRIBE_MEMBER(m_EKeyboardChar, &ImGuiRenderPass::OnKeyboardChar);
+
+    // Prime the first frame
+    newFrame();
+}
+
+void ImGuiRenderPass::Update(double dt)
+{
+    g_DeltaTime = dt;
+}
+
+void ImGuiRenderPass::Draw()
+{
+    ImGuiIO& io = ImGui::GetIO();
+
+    ImGui::Render();
+
+    ImDrawData* draw_data = ImGui::GetDrawData();
+
+    // Set up render state
+    ImGuiRenderState state;
+    glActiveTexture(GL_TEXTURE0);
+
+    // Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
+    float fb_height = io.DisplaySize.y * io.DisplayFramebufferScale.y;
+    draw_data->ScaleClipRects(io.DisplayFramebufferScale);
+
+    // Setup viewport, orthographic projection matrix
+    glViewport(0, 0, (GLsizei)io.DisplaySize.x, (GLsizei)io.DisplaySize.y);
+    const float ortho_projection[4][4] =
+    {
+        { 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f },
+        { 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f },
+        { 0.0f, 0.0f, -1.0f, 0.0f },
+        { -1.0f, 1.0f, 0.0f, 1.0f },
+    };
+    glUseProgram(g_ShaderHandle);
+    glUniform1i(g_AttribLocationTex, 0);
+    glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
+    glBindVertexArray(g_VaoHandle);
+
+    for (int n = 0; n < draw_data->CmdListsCount; n++) {
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        const ImDrawIdx* idx_buffer_offset = 0;
+
+        glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
+        glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), (GLvoid*)&cmd_list->VtxBuffer.front(), GL_STREAM_DRAW);
+
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), (GLvoid*)&cmd_list->IdxBuffer.front(), GL_STREAM_DRAW);
+
+        for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++) {
+            if (pcmd->UserCallback) {
+                pcmd->UserCallback(cmd_list, pcmd);
+            } else {
+                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
+                glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
+            }
+            idx_buffer_offset += pcmd->ElemCount;
+        }
+    }
+
+    // Start next frame
+    newFrame();
+}
+
+bool ImGuiRenderPass::OnMousePress(const Events::MousePress& e)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.MouseDown[e.Button] = true;
+    return false;
+}
+
+bool ImGuiRenderPass::OnMouseRelease(const Events::MouseRelease& e)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.MouseDown[e.Button] = false;
+    return false;
+}
+
+bool ImGuiRenderPass::OnMouseMove(const Events::MouseMove& e)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.MousePos.x = e.X;
+    io.MousePos.y = e.Y;
+    return true;
+}
+
+bool ImGuiRenderPass::OnMouseScroll(const Events::MouseScroll& e)
+{
+    g_MouseWheel += (float)e.DeltaY;
+    return true;
+}
+
+bool ImGuiRenderPass::OnKeyDown(const Events::KeyDown& e)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeysDown[e.KeyCode] = true;
+    return true;
+}
+
+bool ImGuiRenderPass::OnKeyUp(const Events::KeyUp& e)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeysDown[e.KeyCode] = false;
+    return true;
+}
+
+bool ImGuiRenderPass::OnKeyboardChar(const Events::KeyboardChar& e)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    if (e.Char > 0 && e.Char < 0x10000) {
+        io.AddInputCharacter((unsigned short)e.Char);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool ImGuiRenderPass::createDeviceObjects()
+{
+    // Backup GL state
+    GLint last_texture, last_array_buffer, last_vertex_array;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
+    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
+
+    const GLchar *vertex_shader =
+        "#version 330\n"
+        "uniform mat4 ProjMtx;\n"
+        "in vec2 Position;\n"
+        "in vec2 UV;\n"
+        "in vec4 Color;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "	Frag_UV = UV;\n"
+        "	Frag_Color = Color;\n"
+        "	gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* fragment_shader =
+        "#version 330\n"
+        "uniform sampler2D Texture;\n"
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "	Out_Color = Frag_Color * texture( Texture, Frag_UV.st);\n"
+        "}\n";
+
+    g_ShaderHandle = glCreateProgram();
+    g_VertHandle = glCreateShader(GL_VERTEX_SHADER);
+    g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(g_VertHandle, 1, &vertex_shader, 0);
+    glShaderSource(g_FragHandle, 1, &fragment_shader, 0);
+    glCompileShader(g_VertHandle);
+    glCompileShader(g_FragHandle);
+    glAttachShader(g_ShaderHandle, g_VertHandle);
+    glAttachShader(g_ShaderHandle, g_FragHandle);
+    glLinkProgram(g_ShaderHandle);
+
+    g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture");
+    g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx");
+    g_AttribLocationPosition = glGetAttribLocation(g_ShaderHandle, "Position");
+    g_AttribLocationUV = glGetAttribLocation(g_ShaderHandle, "UV");
+    g_AttribLocationColor = glGetAttribLocation(g_ShaderHandle, "Color");
+
+    glGenBuffers(1, &g_VboHandle);
+    glGenBuffers(1, &g_ElementsHandle);
+
+    glGenVertexArrays(1, &g_VaoHandle);
+    glBindVertexArray(g_VaoHandle);
+    glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
+    glEnableVertexAttribArray(g_AttribLocationPosition);
+    glEnableVertexAttribArray(g_AttribLocationUV);
+    glEnableVertexAttribArray(g_AttribLocationColor);
+
+#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
+    glVertexAttribPointer(g_AttribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, pos));
+    glVertexAttribPointer(g_AttribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, uv));
+    glVertexAttribPointer(g_AttribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, col));
+#undef OFFSETOF
+
+    createFontsTexture();
+
+    // Restore modified GL state
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+    glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
+    glBindVertexArray(last_vertex_array);
+
+    return true;
+}
+
+bool ImGuiRenderPass::createFontsTexture()
+{
+    // Build texture atlas
+    ImGuiIO& io = ImGui::GetIO();
+
+    io.Fonts->AddFontFromFileTTF("Fonts/DroidSans.ttf", 13.f);
+    //io.Fonts->AddFontFromFileTTF("Fonts/ProggyClean.ttf", 13.f);
+    //io.Fonts->AddFontFromFileTTF("Fonts/ProggyTiny.ttf", 10.f);
+    //io.Fonts->AddFontFromFileTTF("Fonts/Karla-Regular.ttf", 15.0f);
+
+    unsigned char* pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);   // Load as RGBA 32-bits for OpenGL3 demo because it is more likely to be compatible with user's existing shader.
+
+    // Upload texture to graphics system
+    GLint last_texture;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+    glGenTextures(1, &g_FontTexture);
+    glBindTexture(GL_TEXTURE_2D, g_FontTexture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+
+    // Store our identifier
+    io.Fonts->TexID = (void *)(intptr_t)g_FontTexture;
+
+    // Restore state
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+
+    return true;
+}
+
+void ImGuiRenderPass::newFrame()
+{
+    ImGuiIO& io = ImGui::GetIO();
+
+    // Setup display size (every frame to accommodate for window resizing)
+    int w, h;
+    int display_w, display_h;
+    glfwGetWindowSize(g_Window, &w, &h);
+    glfwGetFramebufferSize(g_Window, &display_w, &display_h);
+    io.DisplaySize = ImVec2((float)w, (float)h);
+    io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
+
+    io.DeltaTime = g_DeltaTime;
+
+    io.KeyCtrl = glfwGetKey(g_Window, GLFW_KEY_LEFT_CONTROL) || glfwGetKey(g_Window, GLFW_KEY_RIGHT_CONTROL);
+    io.KeyShift = glfwGetKey(g_Window, GLFW_KEY_LEFT_SHIFT) || glfwGetKey(g_Window, GLFW_KEY_RIGHT_SHIFT);
+    io.KeyAlt = glfwGetKey(g_Window, GLFW_KEY_LEFT_ALT) || glfwGetKey(g_Window, GLFW_KEY_RIGHT_ALT);
+
+    io.MouseWheel = g_MouseWheel;
+    g_MouseWheel = 0;
+
+    m_EventBroker->Process<ImGuiRenderPass>();
+
+    ImGui::NewFrame();
+}
+

src/Engine/Rendering/PickingPass.cpp

@@ -48,26 +48,31 @@ void PickingPass::Draw(RenderQueueCollection& rq)
     m_PickingColorsToEntity.clear();
     PickingPassState* state = new PickingPassState(m_PickingBuffer.GetHandle());
 
-    int r = 1;
+    int r = 0;
     int g = 0;
     //TODO: Render: Add code for more jobs than modeljobs.
 
     GLuint ShaderHandle = m_PickingProgram->GetHandle();
     m_PickingProgram->Bind();
 
+    std::map<EntityID, glm::vec2> entityColors;
+
     for (auto &job : rq.Forward) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {
-            //---------------
-            //TODO: Renderer: IMPORTANT: Fixa detta så det inte loopar igenom listan varje frame.
-            //---------------
             int pickColor[2] = { r, g };
-            for (auto i : m_PickingColorsToEntity) {
-                if (modelJob->Entity == i.second) {
-                    pickColor[0] = i.first.x;
-                    pickColor[1] = i.first.y;
-                    r -= 1;
+            auto color = entityColors.find(modelJob->Entity);
+            if (color != entityColors.end()) {
+                pickColor[0] = color->second[0];
+                pickColor[1] = color->second[1];
+            } else {
+                entityColors[modelJob->Entity] = glm::vec2(pickColor[0], pickColor[1]);
+                if (r + 10 > 255) {
+                    r = 0;
+                    g += 1;
+                } else {
+                    r += 1;
                 }
             }
             m_PickingColorsToEntity[glm::vec2(pickColor[0], pickColor[1])] = modelJob->Entity;
@@ -82,26 +87,26 @@ void PickingPass::Draw(RenderQueueCollection& rq)
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
             glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
-            r += 1;
-            if (r > 255) {
-                r = 0;
-                g += 1;
-            }
         }
     }
     m_PickingBuffer.Unbind();
     GLERROR("PickingPass Error");
 
     //Publish pick event every frame with the pick data that can be picked by the event
+    int fbWidth;
+    int fbHeight;
+    glfwGetFramebufferSize(m_Renderer->Window(), &fbWidth, &fbHeight);
     Events::Picking pickEvent = Events::Picking(
         &m_PickingBuffer,
         &m_DepthBuffer,
         m_Renderer->Camera()->ProjectionMatrix(),
         m_Renderer->Camera()->ViewMatrix(),
-        m_Renderer->Resolution(),
+        Rectangle(fbWidth, fbHeight),
         &m_PickingColorsToEntity);
 
     m_EventBroker->Publish(pickEvent);
+
+    delete state;
 }
 
 void PickingPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const

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/RawModel.cpp

@@ -8,7 +8,7 @@ RawModel::RawModel(std::string fileName)
 	if (scene == nullptr) {
 		LOG_ERROR("Failed to load model \"%s\"", fileName.c_str());
 		LOG_ERROR("Assimp error: %s", importer.GetErrorString());
-		return;
+        throw std::runtime_error("Failed to open model file.");
 	}
 
 	auto m = scene->mRootNode->mTransformation;
@@ -76,13 +76,15 @@ RawModel::RawModel(std::string fileName)
 			}
 
 			// Material diffuse color
-			aiColor4D diffuse;
+			aiColor3D diffuse;
 			material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuse);
-			desc.DiffuseVertexColor = glm::vec4(diffuse.r, diffuse.g, diffuse.b, diffuse.a);
+            float opacity;
+            material->Get(AI_MATKEY_OPACITY, opacity);
+			desc.DiffuseVertexColor = glm::vec4(diffuse.r, diffuse.g, diffuse.b, opacity);
 			// Material specular color
-			aiColor4D specular;
+			aiColor3D specular;
 			material->Get(AI_MATKEY_COLOR_SPECULAR, specular);
-			desc.SpecularVertexColor = glm::vec4(specular.r, specular.g, specular.b, specular.a);
+			desc.SpecularVertexColor = glm::vec4(specular.r, specular.g, specular.b, 1.f);
 
 			m_Vertices.push_back(desc);
 		}

src/Engine/Rendering/RenderQueueFactory.cpp

@@ -23,15 +23,19 @@ glm::mat4 RenderQueueFactory::ModelMatrix(World* world, EntityID entity)
     return modelMatrix;
 }
 
-
 glm::vec3 RenderQueueFactory::AbsolutePosition(World* world, EntityID entity)
 {
     glm::vec3 position;
 
     do {
         ComponentWrapper transform = world->GetComponent(entity, "Transform");
-        position += (glm::vec3)transform["Position"];
-        entity = world->GetParent(entity);
+        EntityID parent = world->GetParent(entity);
+        if (parent != 0) {
+            position += AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"];
+        } else {
+            position += (glm::vec3)transform["Position"];
+        }
+        entity = parent;
     } while (entity != 0);
    
     return position;
@@ -52,15 +56,15 @@ glm::quat RenderQueueFactory::AbsoluteOrientation(World* world, EntityID entity)
 
 glm::vec3 RenderQueueFactory::AbsoluteScale(World* world, EntityID entity)
 {
-    ComponentWrapper transform = world->GetComponent(entity, "Transform");
-    glm::vec3 scale = (glm::vec3)transform["Scale"];
+    glm::vec3 scale(1.f);
 
-    EntityID parent = world->GetParent(entity);
-    if (parent != 0) {
-        return AbsoluteScale(world, parent) * scale;
-    } else {
-        return scale;
-    }
+    do {
+        ComponentWrapper transform = world->GetComponent(entity, "Transform");
+        scale *= (glm::vec3)transform["Scale"];
+        entity = world->GetParent(entity);
+    } while (entity != 0);
+
+    return scale;
 }
 
 void RenderQueueFactory::FillModels(World* world, RenderQueue* renderQueue)
@@ -71,12 +75,19 @@ void RenderQueueFactory::FillModels(World* world, RenderQueue* renderQueue)
     }
 
     for (auto& modelC : *models) {
+        bool visible = modelC["Visible"];
+        if (!visible) {
+            continue;
+        }
         std::string resource = modelC["Resource"];
         if (resource.empty()) {
             continue;
         }
         glm::vec4 color = modelC["Color"];
         Model* model = ResourceManager::Load<Model>(resource);
+        if (model == nullptr) {
+            model = ResourceManager::Load<Model>("Models/Core/Error.obj");
+        }
 
         for (auto texGroup : model->TextureGroups) {
             ModelJob job;

src/Engine/Rendering/RenderState.cpp

@@ -1,105 +1,100 @@
 #include "Rendering/RenderState.h"
 
-RenderState::RenderState()
+bool RenderState::Enable(GLenum cap)
 {
-
-}
-
-bool RenderState::Enable(GLenum GLEnable)
-{
-    if(glIsEnabled(GLEnable))
-    {
+    if (glIsEnabled(cap)) {
         //LOG_WARNING("Trying to enable somthing that is already enabled.");
         return false;
     }
-    m_Enables.push_back(GLEnable);
-    glEnable(GLEnable);
-    if (GLERROR("RenderState::Enable"))
-    {
-        return false;
-    }
-    return true;
+    m_ResetFunctions.push_back(std::bind(glDisable, cap));
+    glEnable(cap);
+    return !GLERROR("RenderState::Enable");
 }
 
-bool RenderState::CullFace(GLenum GLCullFace)
+bool RenderState::Disable(GLenum cap)
 {
-    if(!glIsEnabled(GL_CULL_FACE))
-    {
-        //LOG_ERROR("Setting GL_CULL_FACE without enabling it.");
-        Enable(GL_CULL_FACE);
-    }
-    
-    glCullFace(GLCullFace);
-    if (GLERROR("RenderState::CullFace"))
-    {
+    if (!glIsEnabled(cap)) {
         return false;
     }
-    return true;
+    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 original;
+    glGetIntegerv(GL_CULL_FACE_MODE, &original);
+    m_ResetFunctions.push_back(std::bind(glCullFace, original));
+    glCullFace(mode);
+    return !GLERROR("RenderState::CullFace");
 }
 
 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 false;
-    }
-    return true;
+    return !GLERROR("RenderState::ClearColor");
 }
 
 bool RenderState::Clear(GLbitfield mask)
 {
     glClear(mask);
-    if (GLERROR("RenderState::Clear")) {
-        return false;
-    }
-    return true;
+    return !GLERROR("RenderState::Clear");
 }
 
-bool RenderState::BindBuffer(GLint buffer)
+bool RenderState::BindFramebuffer(GLint framebuffer)
 {
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_preBuffer);
-    if (buffer == m_preBuffer)
-    {
-        return true;
-    }
-    glBindFramebuffer(GL_FRAMEBUFFER, buffer);
-    if (GLERROR("RenderState::BindBuffer"))
-    {
-        printf("BufferID: %i\npreBufferID: %i\n", buffer, m_preBuffer);
-        return false;
-    }
-    return true;
+    GLint originalRead;
+    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &originalRead);
+    GLint originalDraw;
+    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &originalDraw);
+    m_ResetFunctions.push_back([originalRead, originalDraw]() {
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, originalRead); 
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, originalDraw); 
+    });
+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+    return !GLERROR("RenderState::BindBuffer");
+}
+
+
+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");
-    GLint n_buffer = -1;
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &n_buffer);
-
-    //Set cullface to default
-    if (glIsEnabled(GL_CULL_FACE)) {
-        glCullFace(GL_BACK);
+    for (auto& f : m_ResetFunctions) {
+        f();
     }
-    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");
 }
 

src/Engine/Rendering/Renderer.cpp

@@ -1,4 +1,5 @@
 #include "Rendering/Renderer.h"
+#include "Rendering/DebugCameraInputController.h"
 
 void Renderer::Initialize()
 {
@@ -18,6 +19,8 @@ void Renderer::Initialize()
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
     m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
     m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");
+
+    m_ImGuiRenderPass = new ImGuiRenderPass(this, m_EventBroker);
 }
 
 void Renderer::InitializeWindow()
@@ -79,6 +82,8 @@ void Renderer::InitializeShaders()
 
 void Renderer::InputUpdate(double dt)
 {
+    static DebugCameraInputController<Renderer> firstPersonInputController(m_EventBroker, -1);
+
 	glm::vec3 m_Position = m_Camera->Position();
 	if (glfwGetKey(m_Window, GLFW_KEY_O) == GLFW_PRESS)
 	{
@@ -108,35 +113,16 @@ void Renderer::InputUpdate(double dt)
 		m_CameraMoveSpeed = 0.5f;
 	}
 
-    static double mousePosX, mousePosY;
-    glfwGetCursorPos(m_Window, &mousePosX, &mousePosY);
-
-	if (glfwGetKey(m_Window, GLFW_KEY_SPACE) == GLFW_PRESS) {
-
-		
-		double deltaX, deltaY;
-		deltaX = mousePosX - (float)Resolution().Width / 2;
-		deltaY = mousePosY - (float)Resolution().Height / 2;
-
-		float rotationY = -deltaY / 300.f;
-		float rotationX = -deltaX / 300.f;
-		glm::quat orientation = m_Camera->Orientation();
-		
-		
-		orientation = orientation * glm::angleAxis<float>(rotationY, glm::vec3(1, 0, 0));
-		orientation = glm::angleAxis<float>(rotationX, glm::vec3(0, 1, 0)) * orientation;
-		
-		m_Camera->SetOrientation(orientation);
-
-		glfwSetCursorPos(m_Window, Resolution().Width / 2, Resolution().Height / 2);
-	}
-	m_Camera->SetPosition(m_Position);
+    firstPersonInputController.Update(dt);
+    m_Camera->SetOrientation(firstPersonInputController.Orientation());
+	m_Camera->SetPosition(firstPersonInputController.Position());
 }
 
 void Renderer::Update(double dt)
 {
     m_EventBroker->Process<Renderer>();
     InputUpdate(dt);
+    m_ImGuiRenderPass->Update(dt);
 }
 
 void Renderer::Draw(RenderQueueCollection& rq)
@@ -147,7 +133,9 @@ void Renderer::Draw(RenderQueueCollection& rq)
     
     //m_DrawScenePass->Draw(rq);
     DrawForwardPlus(rq);
+    glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 1.f);
     GLERROR("Renderer::Draw m_DrawScenePass->Draw");
+    m_ImGuiRenderPass->Draw();
 	glfwSwapBuffers(m_Window);
 }
 

src/Engine/Rendering/Util/ScreenCoords.cpp

@@ -32,11 +32,10 @@ glm::vec3 ScreenCoords::ToWorldPos(glm::vec2 screenCoord, float depth, float scr
 ScreenCoords::PixelData ScreenCoords::ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
 {
     PickDataBuffer->Bind();
-    unsigned char pdata[2];
-    glReadPixels(x, y, 1, 1, GL_RG, GL_UNSIGNED_BYTE, &pdata);
+    unsigned char pdata[3];
+    glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pdata);
     PickDataBuffer->Unbind();
 
-
     glBindFramebuffer(GL_FRAMEBUFFER, DepthBuffer);
     float depthData;
     glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depthData);