WIP on widget fuckery

include/Engine/Rendering/Util/GLError.h

@@ -9,7 +9,7 @@ inline bool _GLERROR(const char* info, const char* file, const char* func, unsig
 	GLenum error = glGetError();
 	if (error != GL_NO_ERROR)
 	{
-		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s, %i, %s", info, error, gluErrorString(error));
+		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s\nError code: %i, %s\n", info, error, gluErrorString(error));
 		return true;
 	}
 

resources/Shaders/ExplosionEffect.geom.glsl

@@ -17,6 +17,8 @@ uniform bool ExponentialAccelaration;
 in VertexData{
 	vec3 Position;
 	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 }Input[];
@@ -24,6 +26,8 @@ in VertexData{
 out VertexData{
 	vec3 Position;
 	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 }Output;
@@ -132,6 +136,8 @@ void main()
 			Output.Normal = Input[i].Normal;
 			Output.Position = Input[i].Position;
 			Output.TextureCoordinate = Input[i].TextureCoordinate;
+			Output.Tangent = Input[i].Tangent;
+			Output.BiTangent = Input[i].BiTangent;
 			
 			// convert to model space for the gravity to always be in -y
 			vec4 ExplodedPositionInModelSpace = M * vec4(ExplodedPosition, 1.0);
@@ -154,7 +160,7 @@ void main()
 		// if explosion color should be affected by distance instead of time...
 		if (ColorByDistance == true)
 		{
-			Output.ExplosionColor = vec4(0.0);
+			Output.ExplosionColor = vec4(1.0);
 		}
 		else
 		{
@@ -168,7 +174,9 @@ void main()
 			Output.Normal = Input[i].Normal;
 			Output.Position = Input[i].Position;
 			Output.TextureCoordinate = Input[i].TextureCoordinate;
-			
+			Output.Tangent = Input[i].Tangent;
+			Output.BiTangent = Input[i].BiTangent;
+
 			// no change in position, pass through vertex
 			gl_Position = gl_in[i].gl_Position;
 			EmitVertex();

resources/Shaders/ForwardPlus.frag.glsl

@@ -14,7 +14,6 @@ layout (binding = 1) uniform sampler2D NormalMapTexture;
 layout (binding = 2) uniform sampler2D SpecularMapTexture;
 layout (binding = 3) uniform sampler2D GlowMapTexture;
 
-
 #define TILE_SIZE 16
 
 struct LightSource {
@@ -149,8 +148,9 @@ void main()
 		totalLighting.Specular += light_result.Specular;
 	}
 
-	
+	vec4 color_result = Color * diffuseTexel * DiffuseColor * Input.ExplosionColor;
-	vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
 	
 
 	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;

resources/Shaders/ForwardPlus.vert.glsl

@@ -41,5 +41,5 @@ void main()
 	Output.Normal = vec3(M * vec4(Normal, 0.0));
 	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
  	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
-	Output.ExplosionColor = vec4(0.0);
+	Output.ExplosionColor = vec4(1.0);
 }

src/Engine/Editor/EditorRenderSystem.cpp

@@ -49,7 +49,7 @@ void EditorRenderSystem::Update(double dt)
             glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, entity.World);
             for (auto matGroup : model->MaterialGroups()) {
                 std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f);
-                if(cModel["Transparent"]) {
+                if (cModel["Transparent"]) {
                     scene.TransparentObjects.push_back(modelJob);
                 } else {
                     scene.OpaqueObjects.push_back(modelJob);

src/Engine/Rendering/DrawColorCorrectionPass.cpp

@@ -27,7 +27,7 @@ void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLf
 
     DrawScreenQuadPassState state = DrawScreenQuadPassState();
     m_ColorCorrectionProgram->Bind();
-    glClear(GL_COLOR_BUFFER_BIT);
+    //glClear(GL_COLOR_BUFFER_BIT);
     glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), exposure);
     glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Gamma"), gamma);
 

src/Engine/Rendering/DrawFinalPass.cpp

@@ -44,6 +44,7 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ForwardPlusProgram->BindFragDataLocation(0, "sceneColor");
     m_ForwardPlusProgram->BindFragDataLocation(1, "bloomColor");
     m_ForwardPlusProgram->Link();
+    GLERROR("Creating forward+ program");
 
     m_ExplosionEffectProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectProgram");
     m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
@@ -53,11 +54,12 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ExplosionEffectProgram->BindFragDataLocation(0, "sceneColor");
     m_ExplosionEffectProgram->BindFragDataLocation(1, "bloomColor");
     m_ExplosionEffectProgram->Link();
+    GLERROR("Creating explosion program");
 }
 
 void DrawFinalPass::Draw(RenderScene& scene)
 {
-    GLERROR("DrawFinalPass::Draw: Pre");
+    GLERROR("Pre");
 
     DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
     if (scene.ClearDepth) {
@@ -65,12 +67,12 @@ void DrawFinalPass::Draw(RenderScene& scene)
     }
 
     DrawModelRenderQueues(scene.OpaqueObjects, scene);
-    GLERROR("DrawFinalPass::Draw: OpaqueObjects");
+    GLERROR("OpaqueObjects");
     DrawModelRenderQueues(scene.TransparentObjects, scene);
-    GLERROR("DrawFinalPass::Draw: TransparentObjects");
+    GLERROR("TransparentObjects");
 
-    GLERROR("DrawFinalPass::Draw: END");
     delete state;
+    GLERROR("END");
 }
 
 
@@ -111,7 +113,9 @@ void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm:
 void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& job, RenderScene& scene)
 {
     GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
+    GLERROR("forwardHandle");
     GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
+    GLERROR("explosionHandle");
 
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
@@ -122,10 +126,21 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
         if(explosionEffectJob) {
             //Bind program
+            if(GLERROR("Prebind")) {
+                continue;
+            }
             m_ExplosionEffectProgram->Bind();
+            if(GLERROR("BindProgram")) {
+                continue;
+            }
+
+            //glDisable(GL_CULL_FACE);
 
             //Bind uniforms
             BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
+            if(GLERROR("BindExplosionUniforms")) {
+                continue;
+            }
 
             if (explosionEffectJob->Model->m_RawModel->m_Skeleton != nullptr) {
 
@@ -134,29 +149,35 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                 }
             }
+            if(GLERROR("Animation")) {
+                continue;
+            }
 
             //bind textures
             BindExplosionTextures(explosionEffectJob);
+            if(GLERROR("BindExplosionTextures")) {
+                continue;
+            }
             //draw
             glBindVertexArray(explosionEffectJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
             glDrawElements(GL_TRIANGLES, explosionEffectJob->EndIndex - explosionEffectJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(explosionEffectJob->StartIndex*sizeof(unsigned int)));
-            GLERROR("DrawFinalPass::Model: 1");
+            //glEnable(GL_CULL_FACE);
+            if(GLERROR("explosion effect end")) {
+                continue;
+            }
 
         } else {
             auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
             if (modelJob) {
                 //bind forward program
                 m_ForwardPlusProgram->Bind();
-                GLERROR("DrawFinalPass::Model: 2");
 
                 //bind uniforms
                 BindModelUniforms(forwardHandle, modelJob, scene);
-                GLERROR("DrawFinalPass::Model: 3");
 
                 //bind textures
                 BindModelTextures(modelJob);
-                GLERROR("DrawFinalPass::Model: 4");
 
                 if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
 
@@ -165,13 +186,14 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                         glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                     }
                 }
-                GLERROR("DrawFinalPass::Model: 5");
 
                 //draw
                 glBindVertexArray(modelJob->Model->VAO);
                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
                 glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
-                GLERROR("DrawFinalPass::Model: END");
+                if(GLERROR("models end")) {
+                    continue;
+                }
             }
         }
     }
@@ -180,40 +202,46 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 
 void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene)
 {
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, GL_FALSE, glm::value_ptr(scene.AmbientColor));
+    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+
     glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
 
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
-    glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
     glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
     glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), job->TimeSinceDeath);
     glUniform1f(glGetUniformLocation(shaderHandle, "ExplosionDuration"), job->ExplosionDuration);
     glUniform4fv(glGetUniformLocation(shaderHandle, "EndColor"), 1, glm::value_ptr(job->EndColor));
     glUniform1i(glGetUniformLocation(shaderHandle, "Randomness"), job->Randomness);
+    glUniform1fv(glGetUniformLocation(shaderHandle, "RandomNumbers"), 50, job->RandomNumbers.data());
     glUniform1f(glGetUniformLocation(shaderHandle, "RandomnessScalar"), job->RandomnessScalar);
     glUniform2fv(glGetUniformLocation(shaderHandle, "Velocity"), 1, glm::value_ptr(job->Velocity));
     glUniform1i(glGetUniformLocation(shaderHandle, "ColorByDistance"), job->ColorByDistance);
     glUniform1i(glGetUniformLocation(shaderHandle, "ExponentialAccelaration"), job->ExponentialAccelaration);
+
+    glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
     glUniform4fv(glGetUniformLocation(shaderHandle, "DiffuseColor"), 1, glm::value_ptr(job->DiffuseColor));
-    glUniform1fv(glGetUniformLocation(shaderHandle, "RandomNumbers"), 50, job->RandomNumbers.data());
+    glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(job->FillColor));
+    glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), job->FillPercentage);
+    glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+    GLERROR("END");
 }
 
 void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene)
 {
-    glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
 
     glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
 
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
     glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
     glUniform4fv(glGetUniformLocation(shaderHandle, "DiffuseColor"), 1, glm::value_ptr(job->DiffuseColor));
     glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(job->FillColor));
     glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), job->FillPercentage);
+    glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
 
+    GLERROR("END");
 }
 
 
@@ -225,7 +253,22 @@ void DrawFinalPass::BindExplosionTextures(std::shared_ptr<ExplosionEffectJob>& j
     } else {
         glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
     }
+
     glActiveTexture(GL_TEXTURE1);
+    if (job->NormalTexture != nullptr) {
+        glBindTexture(GL_TEXTURE_2D, job->NormalTexture->m_Texture);
+    } else {
+        glBindTexture(GL_TEXTURE_2D, m_NeutralNormalTexture->m_Texture);
+    }
+
+    glActiveTexture(GL_TEXTURE2);
+    if (job->SpecularTexture != nullptr) {
+        glBindTexture(GL_TEXTURE_2D, job->SpecularTexture->m_Texture);
+    } else {
+        glBindTexture(GL_TEXTURE_2D, m_GreyTexture->m_Texture);
+    }
+
+    glActiveTexture(GL_TEXTURE3);
     if (job->IncandescenceTexture != nullptr) {
         glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture->m_Texture);
     } else {

src/Engine/Rendering/FrameBuffer.cpp

@@ -54,13 +54,6 @@ void FrameBuffer::Generate()
         case GL_RENDERBUFFER:
             glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
             GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
-            if ( (*it)->m_Attachment != GL_COLOR_ATTACHMENT0 ||
-                (*it)->m_Attachment != GL_COLOR_ATTACHMENT1 ||
-                (*it)->m_Attachment != GL_DEPTH_ATTACHMENT ||
-                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT) //TODO: Viktor: Fixa detta
-            {
-                LOG_ERROR("RenderBuffer Attachment not valid.");
-            }
             break;
         }