Add the lensflare shader

data/shaders/lensblend.frag

@@ -0,0 +1,19 @@
+uniform sampler2D tex_128;
+uniform sampler2D tex_256;
+uniform sampler2D tex_512;
+
+out vec4 FragColor;
+
+void main()
+{
+    vec2 uv = gl_FragCoord.xy / screen;
+    vec4 col = .125 * texture(tex_128, uv);
+    col += .25 * texture(tex_256, uv);
+    col += .5 * texture(tex_512, uv);
+    
+    float final = max(col.r,max(col.g,col.b));
+    //final = final * 2;
+    vec3 blue = vec3(final * 0.1, final * 0.2, final);
+    
+    FragColor = vec4(col.rgb, 1.);
+}

src/graphics/post_processing.cpp

@@ -351,6 +351,48 @@ void PostProcessing::renderGaussian6Blur(FrameBuffer &in_fbo, FrameBuffer &auxil
     }
 }
 
+void PostProcessing::renderHorizontalBlur(FrameBuffer &in_fbo, FrameBuffer &auxiliary)
+{
+    assert(in_fbo.getWidth() == auxiliary.getWidth() && in_fbo.getHeight() == auxiliary.getHeight());
+    float inv_width = 1.0f / in_fbo.getWidth(), inv_height = 1.0f / in_fbo.getHeight();
+    {
+        auxiliary.Bind();
+
+        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0]);
+        DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
+    }
+    {
+        in_fbo.Bind();
+
+        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(auxiliary.getRTT()[0]);
+        DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
+    }
+	{
+        auxiliary.Bind();
+
+        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0]);
+        DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
+    }
+    {
+        in_fbo.Bind();
+
+        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(auxiliary.getRTT()[0]);
+        DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
+    }
+	{
+        auxiliary.Bind();
+
+        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0]);
+        DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
+    }
+    {
+        in_fbo.Bind();
+
+        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(auxiliary.getRTT()[0]);
+        DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
+    }
+}
+
 void PostProcessing::renderGaussian17TapBlur(FrameBuffer &in_fbo, FrameBuffer &auxiliary)
 {
     assert(in_fbo.getWidth() == auxiliary.getWidth() && in_fbo.getHeight() == auxiliary.getHeight());
@@ -710,13 +752,21 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode, boo
             // Downsample
             FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_512), irr_driver->getFBO(FBO_BLOOM_256), GL_COLOR_BUFFER_BIT, GL_LINEAR);
             FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_256), irr_driver->getFBO(FBO_BLOOM_128), GL_COLOR_BUFFER_BIT, GL_LINEAR);
+			
+			// Copy for lens flare
+			FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_512), irr_driver->getFBO(FBO_LENS_512), GL_COLOR_BUFFER_BIT, GL_LINEAR);
+			FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_256), irr_driver->getFBO(FBO_LENS_256), GL_COLOR_BUFFER_BIT, GL_LINEAR);
+			FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_128), irr_driver->getFBO(FBO_LENS_128), GL_COLOR_BUFFER_BIT, GL_LINEAR);
+			
 
             // Blur
             renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_512), irr_driver->getFBO(FBO_TMP_512));
-
             renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_256), irr_driver->getFBO(FBO_TMP_256));
-
             renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_128), irr_driver->getFBO(FBO_TMP_128));
+			
+			renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_512), irr_driver->getFBO(FBO_TMP_512));
+            renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_256), irr_driver->getFBO(FBO_TMP_256));
+            renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_128), irr_driver->getFBO(FBO_TMP_128));
 
             // Additively blend on top of tmp1
             in_fbo->Bind();
@@ -727,6 +777,11 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode, boo
                 irr_driver->getRenderTargetTexture(RTT_BLOOM_128), irr_driver->getRenderTargetTexture(RTT_BLOOM_256), irr_driver->getRenderTargetTexture(RTT_BLOOM_512));
             DrawFullScreenEffect<FullScreenShader::BloomBlendShader>();
 
+
+			FullScreenShader::LensBlendShader::getInstance()->SetTextureUnits(
+                irr_driver->getRenderTargetTexture(RTT_LENS_128), irr_driver->getRenderTargetTexture(RTT_LENS_256), irr_driver->getRenderTargetTexture(RTT_LENS_512));
+            DrawFullScreenEffect<FullScreenShader::LensBlendShader>();
+
             glDisable(GL_BLEND);
             glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
         } // end if bloom

src/graphics/post_processing.hpp

@@ -88,6 +88,7 @@ public:
     /** Blur the in texture */
     void renderGaussian3Blur(FrameBuffer &in_fbo, FrameBuffer &auxiliary);
     void renderGaussian6Blur(FrameBuffer &in_fbo, FrameBuffer &auxiliary);
+	void renderHorizontalBlur(FrameBuffer &in_fbo, FrameBuffer &auxiliary);
     void renderGaussian6BlurLayer(FrameBuffer &in_fbo);
     void renderGaussian17TapBlur(FrameBuffer &in_fbo, FrameBuffer &auxiliary);
 

src/graphics/rtts.cpp

@@ -125,10 +125,15 @@ RTT::RTT(size_t width, size_t height)
     RenderTargetTextures[RTT_BLOOM_1024] = generateRTT(shadowsize0, GL_RGBA16F, GL_BGR, GL_FLOAT);
     RenderTargetTextures[RTT_BLOOM_512] = generateRTT(shadowsize1, GL_RGBA16F, GL_BGR, GL_FLOAT);
     RenderTargetTextures[RTT_TMP_512] = generateRTT(shadowsize1, GL_RGBA16F, GL_BGR, GL_FLOAT);
+	RenderTargetTextures[RTT_LENS_512] = generateRTT(shadowsize1, GL_RGBA16F, GL_BGR, GL_FLOAT);
+	
     RenderTargetTextures[RTT_BLOOM_256] = generateRTT(shadowsize2, GL_RGBA16F, GL_BGR, GL_FLOAT);
     RenderTargetTextures[RTT_TMP_256] = generateRTT(shadowsize2, GL_RGBA16F, GL_BGR, GL_FLOAT);
+	RenderTargetTextures[RTT_LENS_256] = generateRTT(shadowsize2, GL_RGBA16F, GL_BGR, GL_FLOAT);
+	
     RenderTargetTextures[RTT_BLOOM_128] = generateRTT(shadowsize3, GL_RGBA16F, GL_BGR, GL_FLOAT);
     RenderTargetTextures[RTT_TMP_128] = generateRTT(shadowsize3, GL_RGBA16F, GL_BGR, GL_FLOAT);
+	RenderTargetTextures[RTT_LENS_128] = generateRTT(shadowsize3, GL_RGBA16F, GL_BGR, GL_FLOAT);
 
     std::vector<GLuint> somevector;
     somevector.push_back(RenderTargetTextures[RTT_SSAO]);
@@ -208,17 +213,30 @@ RTT::RTT(size_t width, size_t height)
     somevector.clear();
     somevector.push_back(RenderTargetTextures[RTT_TMP_512]);
     FrameBuffers.push_back(new FrameBuffer(somevector, 512, 512));
+	somevector.clear();
+    somevector.push_back(RenderTargetTextures[RTT_LENS_512]);
+    FrameBuffers.push_back(new FrameBuffer(somevector, 512, 512));
+
+
     somevector.clear();
     somevector.push_back(RenderTargetTextures[RTT_BLOOM_256]);
     FrameBuffers.push_back(new FrameBuffer(somevector, 256, 256));
     somevector.clear();
     somevector.push_back(RenderTargetTextures[RTT_TMP_256]);
     FrameBuffers.push_back(new FrameBuffer(somevector, 256, 256));
+	somevector.clear();
+    somevector.push_back(RenderTargetTextures[RTT_LENS_256]);
+    FrameBuffers.push_back(new FrameBuffer(somevector, 256, 256));
+
+
     somevector.clear();
     somevector.push_back(RenderTargetTextures[RTT_BLOOM_128]);
     FrameBuffers.push_back(new FrameBuffer(somevector, 128, 128));
     somevector.clear();
     somevector.push_back(RenderTargetTextures[RTT_TMP_128]);
+    FrameBuffers.push_back(new FrameBuffer(somevector, 128, 128));
+	somevector.clear();
+    somevector.push_back(RenderTargetTextures[RTT_LENS_128]);
     FrameBuffers.push_back(new FrameBuffer(somevector, 128, 128));
 
     if (UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround())

src/graphics/shaders.cpp

@@ -1561,6 +1561,16 @@ namespace FullScreenShader
 
         AssignSamplerNames(Program, 0, "tex_128", 1, "tex_256", 2, "tex_512");
     }
+	
+	LensBlendShader::LensBlendShader()
+    {
+        Program = LoadProgram(OBJECT,
+            GL_VERTEX_SHADER, file_manager->getAsset("shaders/screenquad.vert").c_str(),
+            GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/lensblend.frag").c_str());
+        AssignUniforms();
+
+        AssignSamplerNames(Program, 0, "tex_128", 1, "tex_256", 2, "tex_512");
+    }
 
     ToneMapShader::ToneMapShader()
     {
@@ -1706,6 +1716,16 @@ namespace FullScreenShader
 
         AssignSamplerNames(Program, 0, "tex");
     }
+	
+	HorizontalBlurShader::HorizontalBlurShader()
+    {
+        Program = LoadProgram(OBJECT,
+            GL_VERTEX_SHADER, file_manager->getAsset("shaders/screenquad.vert").c_str(),
+            GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/gaussian6h.frag").c_str());
+        AssignUniforms("pixel");
+
+        AssignSamplerNames(Program, 0, "tex");
+    }
 
     Gaussian3HBlurShader::Gaussian3HBlurShader()
     {

src/graphics/shaders.hpp

@@ -377,6 +377,13 @@ public:
     BloomBlendShader();
 };
 
+class LensBlendShader : public ShaderHelperSingleton<LensBlendShader>, public TextureRead<Bilinear_Filtered, Bilinear_Filtered, Bilinear_Filtered>
+{
+public:
+    LensBlendShader();
+};
+
+
 class ToneMapShader : public ShaderHelperSingleton<ToneMapShader, float>, public TextureRead<Nearest_Filtered>
 {
 public:
@@ -455,6 +462,12 @@ public:
     Gaussian6HBlurShader();
 };
 
+class HorizontalBlurShader : public ShaderHelperSingleton<HorizontalBlurShader, core::vector2df>, public TextureRead<Bilinear_Clamped_Filtered>
+{
+public:
+    HorizontalBlurShader();
+};
+
 class Gaussian3HBlurShader : public ShaderHelperSingleton<Gaussian3HBlurShader, core::vector2df>, public TextureRead<Bilinear_Clamped_Filtered>
 {
 public: