From 9b5e4c10fdce35f9175c25c00a35ff9f001cb138 Mon Sep 17 00:00:00 2001 From: FakeShemp Date: Sun, 13 Mar 2016 16:19:17 +0100 Subject: [PATCH 1/2] Shadow will actually shut itself off and delete itself now --- include/Engine/Rendering/DrawFinalPass.h | 1 + include/Engine/Rendering/Renderer.h | 1 + include/Engine/Rendering/ShadowPass.h | 9 +- .../Shaders/ForwardPlusNoShadows.frag.glsl | 204 +++++++++++++ src/Engine/Rendering/DrawFinalPass.cpp | 57 +++- src/Engine/Rendering/Renderer.cpp | 2 + src/Engine/Rendering/ShadowPass.cpp | 275 ++++++++++-------- 7 files changed, 409 insertions(+), 140 deletions(-) create mode 100644 resources/Shaders/ForwardPlusNoShadows.frag.glsl diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h index 26712088..f37e3cc8 100644 --- a/include/Engine/Rendering/DrawFinalPass.h +++ b/include/Engine/Rendering/DrawFinalPass.h @@ -76,6 +76,7 @@ private: const ShadowPass* m_ShadowPass; ShaderProgram* m_ForwardPlusProgram; + ShaderProgram* m_ForwardPlusNoShadowsProgram; ShaderProgram* m_ExplosionEffectProgram; ShaderProgram* m_ExplosionEffectSplatMapProgram; ShaderProgram* m_SpriteProgram; diff --git a/include/Engine/Rendering/Renderer.h b/include/Engine/Rendering/Renderer.h index 51cf62e7..41653739 100644 --- a/include/Engine/Rendering/Renderer.h +++ b/include/Engine/Rendering/Renderer.h @@ -71,6 +71,7 @@ private: bool m_ResizeWindow = false; int m_SSAO_Quality = 0; int m_GLOW_Quality = 2; + bool m_Shadow_Enabled = true; PickingPass* m_PickingPass; LightCullingPass* m_LightCullingPass; diff --git a/include/Engine/Rendering/ShadowPass.h b/include/Engine/Rendering/ShadowPass.h index 122fbddd..1ec62be0 100644 --- a/include/Engine/Rendering/ShadowPass.h +++ b/include/Engine/Rendering/ShadowPass.h @@ -38,6 +38,8 @@ public: void ClearBuffer(); void Draw(RenderScene& scene); + void CheckStatus(bool status); + void DebugGUI(); GLuint DepthMap() const { return m_DepthMap; } @@ -45,6 +47,7 @@ public: std::array LightV() const { return m_LightView; } std::array FarDistance() const { std::array f; for (int i = 0; i < MAX_SPLITS; i++) f[i] = m_shadowFrusta[i].FarClip; return f; } int CurrentNrOfSplits() const { return m_CurrentNrOfSplits; } + bool EnableShadows() const { return m_EnableShadows; } void SetSplitWeight(float split_weight) { m_SplitWeight = split_weight; }; private: @@ -63,8 +66,8 @@ private: GLuint m_DepthMap; FrameBuffer m_DepthBuffer; - ShaderProgram* m_ShadowProgram; - ShaderProgram* m_ShadowProgramSkinned; + ShaderProgram* m_ShadowProgram; + ShaderProgram* m_ShadowProgramSkinned; std::array m_LightProjection; std::array m_LightView; @@ -75,7 +78,7 @@ private: bool m_TransparentObjects = false; bool m_TexturedShadows = false; - bool m_EnableShadows = true; + bool m_EnableShadows = false; int m_CurrentNrOfSplits = 4; float m_SplitWeight = 0.962f; diff --git a/resources/Shaders/ForwardPlusNoShadows.frag.glsl b/resources/Shaders/ForwardPlusNoShadows.frag.glsl new file mode 100644 index 00000000..a0618edf --- /dev/null +++ b/resources/Shaders/ForwardPlusNoShadows.frag.glsl @@ -0,0 +1,204 @@ +#version 430 + +#define MIN_AMBIENT_LIGHT 0.3 +#define MAX_SPLITS 4 + +uniform mat4 VM; +uniform mat4 M; +uniform mat4 V; +uniform mat4 P; +uniform vec4 Color; +uniform vec4 DiffuseColor; +uniform vec2 ScreenDimensions; +uniform vec4 FillColor; +uniform vec4 AmbientColor; +uniform float FillPercentage; +uniform float GlowIntensity; +uniform vec3 CameraPosition; +uniform int SSAOQuality; +uniform float FarDistance[MAX_SPLITS]; + +uniform vec2 DiffuseUVRepeat; +uniform vec2 NormalUVRepeat; +uniform vec2 SpecularUVRepeat; +uniform vec2 GlowUVRepeat; +layout (binding = 0) uniform sampler2D AOTexture; +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 + +struct LightSource { + vec4 Position; + vec4 Direction; + vec4 Color; + float Radius; + float Intensity; + float Falloff; + int Type; +}; + +layout (std430, binding = 1) buffer LightBuffer +{ + LightSource List[]; +} LightSources; + +struct LightGrid { + float Start; + float Amount; + vec2 Padding; +}; + +layout (std430, binding = 2) buffer LightGridBuffer +{ + LightGrid Data[]; +} LightGrids; + +layout (std430, binding = 4) buffer LightIndexBuffer +{ + float LightIndex[]; +}; + +in VertexData{ + vec3 Position; + vec3 Normal; + vec3 Tangent; + vec3 BiTangent; + vec2 TextureCoordinate; + vec4 ExplosionColor; + float ExplosionPercentageElapsed; + vec4 PositionLightSpace[MAX_SPLITS]; +}Input; + +out vec4 sceneColor; +out vec4 bloomColor; + +struct LightResult { + vec4 Diffuse; + vec4 Specular; +}; + +float CalcAttenuation(float radius, float dist, float falloff) { + return 1.0 - smoothstep(radius * falloff, radius, dist); +} + +vec4 CalcSpecular(vec4 lightColor, vec4 viewVec, vec4 lightVec, vec4 normal) { + vec4 R = normalize( reflect(-lightVec, normal)); + float RdotV = max( dot(R, viewVec), 0.0); + return lightColor * pow(RdotV, 90.0); +} + +vec4 CalcDiffuse(vec4 lightColor, vec4 lightVec, vec4 normal) { + float power = max( dot(normal, lightVec), 0.0); + return lightColor * power; +} + +LightResult CalcPointLightSource(vec4 lightPos, float lightRadius, vec4 lightColor, float intensity, vec4 viewVec, vec4 position, vec4 normal, float falloff) +{ + vec4 L = lightPos - position; + float dist = length(L); + L = normalize(L); + + float attenuation = CalcAttenuation(lightRadius, dist, falloff); + + LightResult result; + result.Diffuse = CalcDiffuse(lightColor, L, normal) * attenuation * intensity; + result.Specular = CalcSpecular(lightColor, viewVec, L, normal) * attenuation * intensity; + return result; +} + +LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal) +{ + vec4 L = normalize( -vec4(direction.xyz, 0) ); + + LightResult result; + result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity; + result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity; + return result; +} + +vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap) +{ + mat3 TBN = mat3(tangent, bitangent, normal); + vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0); + return vec4(TBN * normalize(NormalMap), 0.0); +} + +void main() +{ + float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r; + ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) / (1.0 + MIN_AMBIENT_LIGHT); + vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat); + vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat); + vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate * SpecularUVRepeat); + vec4 position = VM * vec4(Input.Position, 1.0); + vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate * NormalUVRepeat, NormalMapTexture); + 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); + tilePos.y = int(gl_FragCoord.y/TILE_SIZE); + + LightResult totalLighting; + totalLighting.Diffuse = vec4(AmbientColor.rgb * ao, 1.0); + int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * int(ScreenDimensions.x/TILE_SIZE))); + + int start = int(LightGrids.Data[currentTile].Start); + int amount = int(LightGrids.Data[currentTile].Amount); + + for(int i = start; i < start + amount; i++) { + + int l = int(LightIndex[i]); + LightSource light = LightSources.List[l]; + + LightResult light_result; + //These if statements should be removed. + if(light.Type == 1) { // point + light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff); + } else if (light.Type == 2) { //Directional + light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal); + } + totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a); + totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a); + } + + 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; + vec4 reflectionTotal = reflectionColor * (1-specularTexel.a) * color_result.a * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)); + color_result = color_result * clamp(1/specularTexel.a, 0, 1) + reflectionTotal; + //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; + + if(pos <= FillPercentage) { + color_result += FillColor; + } + sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1)); + //sceneColor = CommonUniforms.testColour; + //sceneColor = vec4(reflectionColor.xyz, 1); + color_result.xyz += glowTexel.xyz*GlowIntensity; + + bloomColor = vec4(max(color_result.xyz - 1.0, 0.0), clamp(color_result.a, 0, 1)); + + //Tiled Debug Code + /* + if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) { + sceneColor += vec4(0.5, 0, 0, 0); + } else { + sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1); + } + */ +} + + diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp index 6ab4bb3c..d358c92a 100644 --- a/src/Engine/Rendering/DrawFinalPass.cpp +++ b/src/Engine/Rendering/DrawFinalPass.cpp @@ -65,6 +65,15 @@ void DrawFinalPass::InitializeShaderPrograms() m_ForwardPlusProgram->Link(); GLERROR("Creating forward+ program"); + m_ForwardPlusNoShadowsProgram = ResourceManager::Load("#ForwardPlusNoShadowProgram"); + m_ForwardPlusNoShadowsProgram->AddShader(std::shared_ptr(new VertexShader("Shaders/ForwardPlus.vert.glsl"))); + m_ForwardPlusNoShadowsProgram->AddShader(std::shared_ptr(new FragmentShader("Shaders/ForwardPlusNoShadows.frag.glsl"))); + m_ForwardPlusNoShadowsProgram->Compile(); + m_ForwardPlusNoShadowsProgram->BindFragDataLocation(0, "sceneColor"); + m_ForwardPlusNoShadowsProgram->BindFragDataLocation(1, "bloomColor"); + m_ForwardPlusNoShadowsProgram->Link(); + GLERROR("Creating forward+ program without shadows"); + m_ExplosionEffectProgram = ResourceManager::Load("#ExplosionEffectProgram"); m_ExplosionEffectProgram->AddShader(std::shared_ptr(new VertexShader("Shaders/ForwardPlus.vert.glsl"))); m_ExplosionEffectProgram->AddShader(std::shared_ptr(new GeometryShader("Shaders/ExplosionEffect.geom.glsl"))); @@ -354,7 +363,12 @@ void DrawFinalPass::OnWindowResize() void DrawFinalPass::DrawModelRenderQueues(std::list>& jobs, RenderScene& scene) { - GLuint forwardHandle = m_ForwardPlusProgram->GetHandle(); + GLuint forwardHandle; + if (m_ShadowPass->EnableShadows()) { + forwardHandle = m_ForwardPlusProgram->GetHandle(); + } else { + forwardHandle = m_ForwardPlusNoShadowsProgram->GetHandle(); + } GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle(); GLuint explosionSplatMapHandle = m_ExplosionEffectSplatMapProgram->GetHandle(); GLuint forwardSplatMapHandle = m_ForwardPlusSplatMapProgram->GetHandle(); @@ -536,9 +550,13 @@ void DrawFinalPass::DrawModelRenderQueues(std::list>& glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0])); } else { - if (lastShader != m_ForwardPlusProgram->GetHandle()) { - m_ForwardPlusProgram->Bind(); - lastShader = m_ForwardPlusProgram->GetHandle(); + if (lastShader != forwardHandle) { + if (forwardHandle == m_ForwardPlusProgram->GetHandle()) { + m_ForwardPlusProgram->Bind(); + } else { + m_ForwardPlusNoShadowsProgram->Bind(); + } + lastShader = forwardHandle; GLERROR("Bind ForwardPlusProgram program"); glUniform1i(glGetUniformLocation(forwardHandle, "SSAOQuality"), m_SSAOPass->TextureQuality()); glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix())); @@ -623,7 +641,12 @@ void DrawFinalPass::DrawModelRenderQueues(std::list>& void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list>& jobs, RenderScene& scene) { - GLuint forwardHandle = m_ForwardPlusProgram->GetHandle(); + GLuint forwardHandle; + if (m_ShadowPass->EnableShadows()) { + forwardHandle = m_ForwardPlusProgram->GetHandle(); + } else { + forwardHandle = m_ForwardPlusNoShadowsProgram->GetHandle(); + } GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle(); GLuint explosionSplatMapHandle = m_ExplosionEffectSplatMapProgram->GetHandle(); GLuint forwardSplatMapHandle = m_ForwardPlusSplatMapProgram->GetHandle(); @@ -1024,9 +1047,14 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::listGetHandle()) { - m_ForwardPlusProgram->Bind(); - lastShader = m_ForwardPlusProgram->GetHandle(); + if (lastShader != forwardHandle) { + if (forwardHandle == m_ForwardPlusProgram->GetHandle()) { + m_ForwardPlusProgram->Bind(); + } + else { + m_ForwardPlusNoShadowsProgram->Bind(); + } + lastShader = forwardHandle; GLERROR("Bind ForwardPlusProgram program"); glUniform1i(glGetUniformLocation(forwardHandle, "SSAOQuality"), m_SSAOPass->TextureQuality()); glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix())); @@ -1112,7 +1140,12 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list>& jobs, RenderScene& scene) { - GLuint forwardHandle = m_ForwardPlusProgram->GetHandle(); + GLuint forwardHandle; + if (m_ShadowPass->EnableShadows()) { + forwardHandle = m_ForwardPlusProgram->GetHandle(); + } else { + forwardHandle = m_ForwardPlusNoShadowsProgram->GetHandle(); + } GLERROR("forwardHandle"); GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle(); GLERROR("explosionHandle"); @@ -1171,7 +1204,11 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list(job); if (modelJob) { //bind forward program - m_ForwardPlusProgram->Bind(); + if (m_ShadowPass->EnableShadows()) { + m_ForwardPlusProgram->Bind(); + } else { + m_ForwardPlusNoShadowsProgram->Bind(); + } glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height); //bind uniforms diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp index 63d7dfaf..6fd6d160 100644 --- a/src/Engine/Rendering/Renderer.cpp +++ b/src/Engine/Rendering/Renderer.cpp @@ -168,8 +168,10 @@ void Renderer::Draw(RenderFrame& frame) ImGui::SliderInt("SSAO Quality", &m_SSAO_Quality, 0, 3); ImGui::SliderInt("Glow Quality", &m_GLOW_Quality, 0, 3); + ImGui::Checkbox("EnableShadows", &m_Shadow_Enabled); m_SSAOPass->ChangeQuality(m_SSAO_Quality); m_DrawBloomPass->ChangeQuality(m_GLOW_Quality); + m_ShadowPass->CheckStatus(m_Shadow_Enabled); GLERROR("SSAO Settings"); //clear buffer 0 glClearColor(0.f, 0.f, 0.f, 0.f); diff --git a/src/Engine/Rendering/ShadowPass.cpp b/src/Engine/Rendering/ShadowPass.cpp index ed9ccb7b..48e47157 100644 --- a/src/Engine/Rendering/ShadowPass.cpp +++ b/src/Engine/Rendering/ShadowPass.cpp @@ -6,7 +6,7 @@ ShadowPass::ShadowPass(IRenderer * renderer, int shadow_res_x, int shadow_res_y) m_ResolutionSizeWidth = shadow_res_x; m_ResolutionSizeHeight = shadow_res_y; - InitializeFrameBuffers(); + CheckStatus(true); InitializeShaderPrograms(); } @@ -14,18 +14,17 @@ ShadowPass::ShadowPass(IRenderer * renderer) { m_Renderer = renderer; - InitializeFrameBuffers(); + CheckStatus(true); InitializeShaderPrograms(); } ShadowPass::~ShadowPass() { - + glDeleteTextures(1, &m_DepthMap); } void ShadowPass::DebugGUI() { - ImGui::Checkbox("EnableShadows", &m_EnableShadows); ImGui::DragFloat2("ShadowMapNearFar", m_NearFarPlane, 1.f, -1000.f, 1000.f); ImGui::DragFloat("ShadowClippingWeight", &m_SplitWeight, 0.001f, 0.f, 1.f); ImGui::Checkbox("ShadowTransparentObjects", &m_TransparentObjects); @@ -126,6 +125,7 @@ float ShadowPass::FindRadius(ShadowFrustum& frustum) void ShadowPass::InitializeFrameBuffers() { // Depth texture + glDeleteTextures(1, &m_DepthMap); glGenTextures(1, &m_DepthMap); glBindTexture(GL_TEXTURE_2D_ARRAY, m_DepthMap); @@ -156,12 +156,12 @@ void ShadowPass::InitializeShaderPrograms() m_ShadowProgram->BindFragDataLocation(0, "ShadowMap"); m_ShadowProgram->Link(); - m_ShadowProgramSkinned = ResourceManager::Load("#ShadowProgramSkinned"); - m_ShadowProgramSkinned->AddShader(std::shared_ptr(new VertexShader("Shaders/ShadowSkinned.vert.glsl"))); - m_ShadowProgramSkinned->AddShader(std::shared_ptr(new FragmentShader("Shaders/Shadow.frag.glsl"))); - m_ShadowProgramSkinned->Compile(); - m_ShadowProgramSkinned->BindFragDataLocation(0, "ShadowMap"); - m_ShadowProgramSkinned->Link(); + m_ShadowProgramSkinned = ResourceManager::Load("#ShadowProgramSkinned"); + m_ShadowProgramSkinned->AddShader(std::shared_ptr(new VertexShader("Shaders/ShadowSkinned.vert.glsl"))); + m_ShadowProgramSkinned->AddShader(std::shared_ptr(new FragmentShader("Shaders/Shadow.frag.glsl"))); + m_ShadowProgramSkinned->Compile(); + m_ShadowProgramSkinned->BindFragDataLocation(0, "ShadowMap"); + m_ShadowProgramSkinned->Link(); } void ShadowPass::ClearBuffer() @@ -209,53 +209,109 @@ void ShadowPass::RadiusToLightspace(ShadowFrustum& frustum) frustum.LRBT = { left, right, bottom, top }; } +void ShadowPass::CheckStatus(bool shadowStatus) +{ + if (m_EnableShadows == shadowStatus) { + return; + } + + m_EnableShadows = shadowStatus; + + if (m_EnableShadows == false) { + glDeleteTextures(1, &m_DepthMap); + return; + } + + InitializeFrameBuffers(); +} + void ShadowPass::Draw(RenderScene & scene) { - if (m_EnableShadows) { - InitializeCameras(scene); - UpdateSplitDist(m_shadowFrusta, scene.Camera->NearClip(), scene.Camera->FarClip()); + if (!m_EnableShadows) { + return; + } - ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle()); + InitializeCameras(scene); + UpdateSplitDist(m_shadowFrusta, scene.Camera->NearClip(), scene.Camera->FarClip()); - - glViewport(0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight); + ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle()); - for (int i = 0; i < m_CurrentNrOfSplits; i++) { - UpdateFrustumPoints(m_shadowFrusta[i], scene.Camera->Position(), scene.Camera->Forward()); + glViewport(0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight); - glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i); + for (int i = 0; i < m_CurrentNrOfSplits; i++) { + UpdateFrustumPoints(m_shadowFrusta[i], scene.Camera->Position(), scene.Camera->Forward()); + + glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i); + + GLuint shaderHandle; + + for (auto &job : scene.Jobs.DirectionalLight) { + + auto directionalLightJob = std::dynamic_pointer_cast(job); + + if (directionalLightJob) { + m_LightView[i] = glm::lookAt(glm::vec3(-directionalLightJob->Direction) + m_shadowFrusta[i].MiddlePoint, m_shadowFrusta[i].MiddlePoint, glm::vec3(0.f, 1.f, 0.f)); + + PointsToLightspace(m_shadowFrusta[i], m_LightView[i]); + //FindRadius(m_shadowFrusta[i]); + //RadiusToLightspace(m_shadowFrusta[i]); + m_LightProjection[i] = glm::ortho(m_shadowFrusta[i].LRBT[LEFT], m_shadowFrusta[i].LRBT[RIGHT], m_shadowFrusta[i].LRBT[BOTTOM], m_shadowFrusta[i].LRBT[TOP], m_NearFarPlane[NEAR], m_NearFarPlane[FAR]); - GLuint shaderHandle; + m_ShadowProgram->Bind(); + shaderHandle = m_ShadowProgram->GetHandle(); + glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i])); + glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i])); - for (auto &job : scene.Jobs.DirectionalLight) { - - auto directionalLightJob = std::dynamic_pointer_cast(job); - - if (directionalLightJob) { - m_LightView[i] = glm::lookAt(glm::vec3(-directionalLightJob->Direction) + m_shadowFrusta[i].MiddlePoint, m_shadowFrusta[i].MiddlePoint, glm::vec3(0.f, 1.f, 0.f)); - - PointsToLightspace(m_shadowFrusta[i], m_LightView[i]); - //FindRadius(m_shadowFrusta[i]); - //RadiusToLightspace(m_shadowFrusta[i]); - m_LightProjection[i] = glm::ortho(m_shadowFrusta[i].LRBT[LEFT], m_shadowFrusta[i].LRBT[RIGHT], m_shadowFrusta[i].LRBT[BOTTOM], m_shadowFrusta[i].LRBT[TOP], m_NearFarPlane[NEAR], m_NearFarPlane[FAR]); - - - m_ShadowProgram->Bind(); - shaderHandle = m_ShadowProgram->GetHandle(); - glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i])); - glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i])); - - m_ShadowProgramSkinned->Bind(); - shaderHandle = m_ShadowProgramSkinned->GetHandle(); - glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i])); - glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i])); + m_ShadowProgramSkinned->Bind(); + shaderHandle = m_ShadowProgramSkinned->GetHandle(); + glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i])); + glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i])); - GLERROR("ShadowLight ERROR"); + GLERROR("ShadowLight ERROR"); - for (auto &objectJob : scene.Jobs.OpaqueObjects) { + for (auto &objectJob : scene.Jobs.OpaqueObjects) { + if (!std::dynamic_pointer_cast(objectJob)) { + auto modelJob = std::dynamic_pointer_cast(objectJob); + + if (!modelJob->Shadow) { + continue; + } + + if (modelJob->Model->IsSkinned()) { + m_ShadowProgramSkinned->Bind(); + shaderHandle = m_ShadowProgramSkinned->GetHandle(); + + std::vector frameBones; + if (modelJob->BlendTree != nullptr) { + frameBones = modelJob->BlendTree->GetFinalPose(); + } + else { + frameBones = modelJob->Skeleton->GetTPose(); + } + glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0])); + + } + else { + m_ShadowProgram->Bind(); + shaderHandle = m_ShadowProgram->GetHandle(); + } + + glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix)); + glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), 1.f); + + 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("Shadow Draw ERROR"); + } + } + if (m_TransparentObjects) { + state->CullFace(GL_BACK); + for (auto &objectJob : scene.Jobs.TransparentObjects) { if (!std::dynamic_pointer_cast(objectJob)) { auto modelJob = std::dynamic_pointer_cast(objectJob); @@ -263,25 +319,53 @@ void ShadowPass::Draw(RenderScene & scene) continue; } - if(modelJob->Model->IsSkinned()) { - m_ShadowProgramSkinned->Bind(); - shaderHandle = m_ShadowProgramSkinned->GetHandle(); + if (modelJob->Model->IsSkinned()) { + m_ShadowProgramSkinned->Bind(); + shaderHandle = m_ShadowProgramSkinned->GetHandle(); - std::vector frameBones; - if (modelJob->BlendTree != nullptr) { - frameBones = modelJob->BlendTree->GetFinalPose(); - } else { - frameBones = modelJob->Skeleton->GetTPose(); - } - glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0])); + std::vector frameBones; + if (modelJob->BlendTree != nullptr) { + frameBones = modelJob->BlendTree->GetFinalPose(); + } + else { + frameBones = modelJob->Skeleton->GetTPose(); + } + glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0])); - } else { - m_ShadowProgram->Bind(); - shaderHandle = m_ShadowProgram->GetHandle(); - } + } + else { + m_ShadowProgram->Bind(); + shaderHandle = m_ShadowProgram->GetHandle(); + } glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix)); - glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), 1.f); + glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), modelJob->Color.a); + + if (m_TexturedShadows) { + switch (modelJob->Type) { + case RawModel::MaterialType::SingleTextures: + case RawModel::MaterialType::Basic: + { + glActiveTexture(GL_TEXTURE24); + if (modelJob->DiffuseTexture.size() > 0 && modelJob->DiffuseTexture[0]->Texture != nullptr) { + glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture[0]->Texture->m_Texture); + glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(modelJob->DiffuseTexture[0]->UVRepeat)); + } + else { + glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture); + glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f))); + } + break; + } + case RawModel::MaterialType::SplatMapping: + { + glActiveTexture(GL_TEXTURE24); + glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture); + glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f))); + break; + } + } + } glBindVertexArray(modelJob->Model->VAO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer); @@ -290,76 +374,13 @@ void ShadowPass::Draw(RenderScene & scene) GLERROR("Shadow Draw ERROR"); } } - if (m_TransparentObjects) { - state->CullFace(GL_BACK); - for (auto &objectJob : scene.Jobs.TransparentObjects) { - if (!std::dynamic_pointer_cast(objectJob)) { - auto modelJob = std::dynamic_pointer_cast(objectJob); - - if (!modelJob->Shadow) { - continue; - } - - if (modelJob->Model->IsSkinned()) { - m_ShadowProgramSkinned->Bind(); - shaderHandle = m_ShadowProgramSkinned->GetHandle(); - - std::vector frameBones; - if (modelJob->BlendTree != nullptr) { - frameBones = modelJob->BlendTree->GetFinalPose(); - } else { - frameBones = modelJob->Skeleton->GetTPose(); - } - glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0])); - - } else { - m_ShadowProgram->Bind(); - shaderHandle = m_ShadowProgram->GetHandle(); - } - - glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix)); - glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), modelJob->Color.a); - - if (m_TexturedShadows) { - switch (modelJob->Type) { - case RawModel::MaterialType::SingleTextures: - case RawModel::MaterialType::Basic: - { - glActiveTexture(GL_TEXTURE24); - if (modelJob->DiffuseTexture.size() > 0 && modelJob->DiffuseTexture[0]->Texture != nullptr) { - glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture[0]->Texture->m_Texture); - glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(modelJob->DiffuseTexture[0]->UVRepeat)); - } - else { - glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture); - glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f))); - } - break; - } - case RawModel::MaterialType::SplatMapping: - { - glActiveTexture(GL_TEXTURE24); - glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture); - glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f))); - break; - } - } - } - - 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("Shadow Draw ERROR"); - } - } - state->CullFace(GL_FRONT); - } + state->CullFace(GL_FRONT); } } } - glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height); - m_DepthBuffer.Unbind(); - delete state; } + + glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height); + m_DepthBuffer.Unbind(); + delete state; } \ No newline at end of file From 8e150da7fffa80d2179c6cf758844fcd38a721f8 Mon Sep 17 00:00:00 2001 From: FakeShemp Date: Sun, 13 Mar 2016 21:25:04 +0100 Subject: [PATCH 2/2] Use CommonFunctions::DeleteTexture() instead --- src/Engine/Rendering/ShadowPass.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Engine/Rendering/ShadowPass.cpp b/src/Engine/Rendering/ShadowPass.cpp index 48e47157..225e1219 100644 --- a/src/Engine/Rendering/ShadowPass.cpp +++ b/src/Engine/Rendering/ShadowPass.cpp @@ -20,7 +20,7 @@ ShadowPass::ShadowPass(IRenderer * renderer) ShadowPass::~ShadowPass() { - glDeleteTextures(1, &m_DepthMap); + CommonFunctions::DeleteTexture(&m_DepthMap); } void ShadowPass::DebugGUI() @@ -218,7 +218,7 @@ void ShadowPass::CheckStatus(bool shadowStatus) m_EnableShadows = shadowStatus; if (m_EnableShadows == false) { - glDeleteTextures(1, &m_DepthMap); + CommonFunctions::DeleteTexture(&m_DepthMap); return; }