Merge pull request #132 from teamfisk/CubeMap

Cube map

include/Engine/Rendering/CubeMapPass.h

@@ -0,0 +1,27 @@
+#ifndef CubeMapPass_h__
+#define CubeMapPass_h__
+
+#include "IRenderer.h"
+#include "ShaderProgram.h"
+
+class CubeMapPass
+{
+public:
+    CubeMapPass(IRenderer* renderer);
+    ~CubeMapPass() { }
+
+    void LoadTextures(std::string input);
+    void FillCubeMap(glm::vec3 originPosition);
+    void GenerateCubeMapTexture();
+
+    //GLuint CubeMapTexture() const { return m_CubeMapTexture; }
+    GLuint m_CubeMapTexture = -1;
+
+private:
+    IRenderer* m_Renderer;
+    std::string m_PreviusCubeMapTexture;
+
+    std::vector<Texture*> m_CubeMapTextures;
+};
+
+#endif 

include/Engine/Rendering/DrawFinalPass.h

@@ -4,6 +4,7 @@
 #include "IRenderer.h"
 #include "DrawFinalPassState.h"
 #include "LightCullingPass.h"
+#include "CubeMapPass.h"
 #include "FrameBuffer.h"
 #include "ShaderProgram.h"
 #include "Util/UnorderedMapVec2.h"
@@ -13,7 +14,7 @@
 class DrawFinalPass
 {
 public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass);
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass);
     ~DrawFinalPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
@@ -62,12 +63,14 @@ private:
     GLuint m_SceneTextureLowRes;
     GLuint m_DepthBuffer;
     GLuint m_DepthBufferLowRes;
+    GLuint m_CubeMapTexture;
 
     //maqke this component based i guess?
     GLuint m_ShieldPixelRate = 16;
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
+    const CubeMapPass* m_CubeMapPass;
 
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;

include/Engine/Rendering/Renderer.h

@@ -17,6 +17,7 @@
 #include "DrawBloomPass.h"
 #include "DrawColorCorrectionPass.h"
 #include "SSAOPass.h"
+#include "CubeMapPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
@@ -58,6 +59,7 @@ private:
     Model* m_UnitSphere;
 
     int m_DebugTextureToDraw = 0;
+    int m_CubeMapTexture = 0;
     bool m_ResizeWindow = false;
 	float m_SSAO_Radius = 1.0f;
 	float m_SSAO_Bias = 0.05f;
@@ -74,6 +76,7 @@ private:
     DrawBloomPass* m_DrawBloomPass;
     DrawColorCorrectionPass* m_DrawColorCorrectionPass;
 	SSAOPass* m_SSAOPass;
+    CubeMapPass* m_CubeMapPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();

include/Engine/Rendering/Texture.h

@@ -18,6 +18,7 @@ public:
 	void Bind(GLenum textureUnit = GL_TEXTURE0);
 
 	GLuint m_Texture = 0;
+    unsigned char* Data = nullptr;
     
 };
 

resources/Shaders/ForwardPlus.frag.glsl

@@ -12,6 +12,7 @@ uniform vec4 FillColor;
 uniform vec4 AmbientColor;
 uniform float FillPercentage;
 uniform float GlowIntensity = 10;
+uniform vec3 CameraPosition;
 
 uniform vec2 DiffuseUVRepeat;
 uniform vec2 NormalUVRepeat;
@@ -22,6 +23,7 @@ layout (binding = 1) uniform sampler2D DiffuseTexture;
 layout (binding = 2) uniform sampler2D NormalMapTexture;
 layout (binding = 3) uniform sampler2D SpecularMapTexture;
 layout (binding = 4) uniform sampler2D GlowMapTexture;
+layout (binding = 5) uniform samplerCube CubeMap;
 
 #define TILE_SIZE 16
 
@@ -76,7 +78,7 @@ struct LightResult {
 };
 
 float CalcAttenuation(float radius, float dist, float falloff) {
-	return 1.0 - smoothstep(radius * 0.3, radius, dist);
+	return 1.0 - smoothstep(radius * falloff, radius, dist);
 }
 
 vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
@@ -133,6 +135,10 @@ void main()
 	normal = normalize(normal);
 	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
 	vec4 viewVec = normalize(-position);
+	vec3 I = normalize(vec3(M * vec4(Input.Position, 1.0)) - CameraPosition);
+	vec3 R = reflect(-I, Input.Normal);
+	//R = vec3(P * vec4(R, 1.0));
+	vec4 reflectionColor = texture(CubeMap, R);
 
 	vec2 tilePos;
 	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
@@ -163,6 +169,8 @@ void main()
 
 	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
 	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
+	color_result = color_result * clamp(1/specularTexel, 0, 1)*2 + reflectionColor * clamp(specularTexel, 0, 1)/2;
 	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
 	
 
@@ -172,9 +180,10 @@ void main()
 		color_result += FillColor;
 	}
 	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	//sceneColor = vec4(reflectionColor.xyz, 1);
 	color_result += glowTexel*GlowIntensity;
 
-	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), clamp(color_result.a, 0, 1));
 
 	//Tiled Debug Code
 	/*

resources/Shaders/ForwardPlus.vert.glsl

@@ -23,12 +23,12 @@ out VertexData{
 void main()
 {
 	gl_Position = P*V*M * vec4(Position, 1.0);
-	
+	mat4 TIM = transpose(inverse(M));
 	Output.Position = Position;
 	Output.TextureCoordinate = TextureCoords;
-	Output.Normal = vec3(M * vec4(Normal, 0.0));
+	Output.Normal = vec3(TIM * vec4(Normal, 0.0));
-	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
+	Output.Tangent = vec3(TIM * vec4(Tangent, 0.0));
- 	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
+ 	Output.BiTangent = vec3(TIM * vec4(BiTangent, 0.0));
 	Output.ExplosionColor = vec4(1.0);
 	Output.ExplosionPercentageElapsed = 0.0;
 }

src/Engine/Rendering/CubeMapPass.cpp

@@ -0,0 +1,40 @@
+#include "Rendering/CubeMapPass.h"
+
+CubeMapPass::CubeMapPass(IRenderer* renderer)
+    :m_Renderer(renderer)
+{
+    LoadTextures("Nevada");
+}
+
+void CubeMapPass::LoadTextures(std::string input)
+{
+    if (m_PreviusCubeMapTexture != input) {
+        m_CubeMapTextures.clear();
+        for (int i = 0; i < 6; i++) {
+            std::string str;
+            str = "Textures/Test/CubeMap/" + input + "/CubeMapTest0" + std::to_string(i) + ".png";
+            Texture* img = ResourceManager::Load<Texture>(str);
+            m_CubeMapTextures.push_back(img);
+        }
+        GenerateCubeMapTexture();
+    }
+}
+
+void CubeMapPass::GenerateCubeMapTexture()
+{
+    if (m_CubeMapTexture == -1) {
+        glGenTextures(1, &m_CubeMapTexture);
+    }
+    glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapTexture);
+
+    for (int i = 0; i < 6; i++) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA32F, m_CubeMapTextures[0]->Width, m_CubeMapTextures[0]->Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_CubeMapTextures[i]->Data);
+    }
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+    GLERROR("Generate Cubemap");
+}
+

src/Engine/Rendering/DrawBloomPass.cpp

@@ -52,6 +52,7 @@ void DrawBloomPass::InitializeBuffers()
 
 void DrawBloomPass::ClearBuffer()
 {
+    GLERROR("PRE");
     m_GaussianFrameBuffer_horiz.Bind();
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -60,6 +61,7 @@ void DrawBloomPass::ClearBuffer()
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_GaussianFrameBuffer_vert.Unbind();
+    GLERROR("END");
 }
 
 void DrawBloomPass::Draw(GLuint texture)

src/Engine/Rendering/DrawFinalPass.cpp

@@ -1,10 +1,11 @@
 #include "Rendering/DrawFinalPass.h"
 
-DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass)
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass)
+    : m_Renderer(renderer)
+    , m_LightCullingPass(lightCullingPass)
+    , m_CubeMapPass(cubeMapPass)
 {
     //TODO: Make sure that uniforms are not sent into shader if not needed.
-    m_Renderer = renderer;
-    m_LightCullingPass = lightCullingPass;
     m_ShieldPixelRate = 8;
     InitializeTextures();
     InitializeShaderPrograms();
@@ -192,8 +193,10 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
     state->StencilMask(0x00);
     DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene, SSAOTexture);
     GLERROR("OpaqueObjects");
+    state->BlendFunc(GL_ONE, GL_ONE);
     DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene, SSAOTexture);
     GLERROR("TransparentObjects");
+    state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     DrawSprites(scene.Jobs.SpriteJob, scene);
     GLERROR("SpriteJobs");
 
@@ -259,20 +262,35 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
 
 void DrawFinalPass::ClearBuffer()
 {
+    GLERROR("PRE");
     m_FinalPassFrameBufferLowRes.Bind();
+    GLERROR("Bind LowRes");
+
     glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_ShieldPixelRate, m_Renderer->GetViewportSize().Height/m_ShieldPixelRate);
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    GLERROR("ViewPort,Scissor LowRes");
+
     glClearColor(0.f, 0.f, 0.f, 0.f);
+    GLERROR("1");
+
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    GLERROR("2");
+
     glDisable(GL_SCISSOR_TEST);
+    GLERROR("3");
+
     m_FinalPassFrameBufferLowRes.Unbind();
 
+    GLERROR("prebind HighRes");
     m_FinalPassFrameBuffer.Bind();
+    GLERROR("Bind HighRes");
     glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    GLERROR("ViewPort,Scissor LowRes");
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_FinalPassFrameBuffer.Unbind();
+    GLERROR("END");
 }
 
 
@@ -356,12 +374,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
             case RawModel::MaterialType::SingleTextures:
             {
                 if (explosionEffectJob->Model->IsSkinned()) {
+
                     m_ExplosionEffectSkinnedProgram->Bind();
                     GLERROR("Bind ExplosionEffectSkinned program");
                     //bind uniforms
                     BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
                     //bind textures
                     BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
+                    glActiveTexture(GL_TEXTURE5);
+                    glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
                     std::vector<glm::mat4> frameBones;
                     if (explosionEffectJob->AnimationOffset.animation != nullptr) {
                         frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
@@ -376,6 +399,10 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
                     //bind textures
                     BindExplosionTextures(explosionHandle, explosionEffectJob);
+                    glActiveTexture(GL_TEXTURE5);
+                    glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
                 }
                 break;
             }
@@ -434,6 +461,10 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
                             //bind textures
                             BindModelTextures(forwardSkinnedHandle, modelJob);
+                            glActiveTexture(GL_TEXTURE5);
+                            glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                            glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
                             std::vector<glm::mat4> frameBones;
                             if (modelJob->AnimationOffset.animation != nullptr) {
                                 frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
@@ -449,6 +480,9 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             BindModelUniforms(forwardHandle, modelJob, scene);
                             //bind textures
                             BindModelTextures(forwardHandle, modelJob);
+                            glActiveTexture(GL_TEXTURE5);
+                            glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                            glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
                         }
                         break;
                     }
@@ -807,6 +841,8 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 
 void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job)
 {
+
+
 	switch (job->Type) {
 	case RawModel::MaterialType::SingleTextures:
 	case RawModel::MaterialType::Basic:

src/Engine/Rendering/PickingPass.cpp

@@ -54,6 +54,7 @@ void PickingPass::InitializeShaderPrograms()
 
 void PickingPass::Draw(RenderScene& scene)
 {
+    GLERROR("PRE");
     PickingPassState* state = new PickingPassState(m_PickingBuffer.GetHandle());
 
     //TODO: Render: Add code for more jobs than modeljobs.
@@ -357,6 +358,7 @@ void PickingPass::Draw(RenderScene& scene)
 
 void PickingPass::ClearPicking()
 {
+    GLERROR("PRE");
     m_PickingColorsToEntity.clear();
     m_EntityColors.clear();
     m_ColorCounter[0] = 0;
@@ -366,6 +368,7 @@ void PickingPass::ClearPicking()
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_PickingBuffer.Unbind();
+    GLERROR("END");
 }
 
 

src/Engine/Rendering/PickingPassState.cpp

@@ -3,9 +3,9 @@
 
 PickingPassState::PickingPassState(GLuint frameBuffer)
 {
-    GLERROR("---2");
+    GLERROR("PRE");
     BindFramebuffer(frameBuffer);
-    GLERROR("---3");
+    GLERROR("Bind Framebuffer");
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
     Disable(GL_BLEND);
@@ -13,6 +13,7 @@ PickingPassState::PickingPassState(GLuint frameBuffer)
     glm::vec4 clearColor = glm::vec4(0.f);
     //ClearColor(clearColor);
     //Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    GLERROR("END");
 }
 
 PickingPassState::~PickingPassState()

src/Engine/Rendering/Renderer.cpp

@@ -89,9 +89,6 @@ void Renderer::InitializeShaders()
     //m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ExplosionEffect.frag.glsl")));
     //m_ExplosionEffectProgram->Compile();
     //m_ExplosionEffectProgram->Link();
-
-
-
 }
 
 void Renderer::InputUpdate(double dt)
@@ -109,7 +106,14 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
+    GLERROR("PRE");
     ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0Ambient Occlusion");
+    ImGui::Combo("CubeMap", &m_CubeMapTexture, "Nevada(512)\0Sky(1024)");
+    if(m_CubeMapTexture == 0) {
+        m_CubeMapPass->LoadTextures("Nevada");
+    } else if (m_CubeMapTexture == 1) {
+        m_CubeMapPass->LoadTextures("Sky");
+    }
 
 	ImGui::SliderFloat("SSAO sample radius", &m_SSAO_Radius, 0.01f, 5.0f);
 	ImGui::SliderFloat("SSAO bias", &m_SSAO_Bias, 0.0f, 0.1f);
@@ -118,6 +122,7 @@ void Renderer::Draw(RenderFrame& frame)
 	ImGui::SliderInt("SSAO Number of Samples", &m_SSAO_NumOfSamples, 2, 100);
 	ImGui::SliderInt("SSAO Number of Turns", &m_SSAO_NumOfTurns, 0, 50);
 	m_SSAOPass->Setting(m_SSAO_Radius, m_SSAO_Bias, m_SSAO_Contrast, m_SSAO_IntensityScale, m_SSAO_NumOfSamples, m_SSAO_NumOfTurns);
+    GLERROR("SSAO Settings");
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -129,6 +134,7 @@ void Renderer::Draw(RenderFrame& frame)
     m_DrawBloomPass->ClearBuffer();
 	m_SSAOPass->ClearBuffer();
     PerformanceTimer::StopTimer("Renderer-ClearBuffers");
+    GLERROR("ClearBuffers");
 	for (auto scene : frame.RenderScenes) {
 		PerformanceTimer::StartTimer("Renderer-Depth");
 		m_PickingPass->Draw(*scene);
@@ -241,9 +247,10 @@ void Renderer::InitializeRenderPasses()
 {
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
-    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
+    m_CubeMapPass = new CubeMapPass(this);
+    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass);
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
     m_DrawBloomPass = new DrawBloomPass(this);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
-	m_SSAOPass = new SSAOPass(this);
+    m_SSAOPass = new SSAOPass(this);
 }

src/Engine/Rendering/Texture.cpp

@@ -18,6 +18,7 @@ Texture::Texture(std::string path)
 
     this->Width = img->Width;
     this->Height = img->Height;
+    this->Data = img->Data;
 
     GLint format;
     switch (img->Format) {
@@ -29,6 +30,7 @@ Texture::Texture(std::string path)
         break;
     }
     
+
     // Construct the OpenGL texture
     glGenTextures(1, &m_Texture);
     glBindTexture(GL_TEXTURE_2D, m_Texture);