Merge lp:~unity-team/nux/linear-sample-blur into lp:nux

[Nicolas d'Offay]

Added linear sample gaussian blur shader which halves the loop count of our vertical and horizontal blur drastically improving performance.

[Nicolas d'Offay (nicolas-doffay)]

review: Approve

=== modified file 'NuxGraphics/GraphicsEngine.cpp'
--- NuxGraphics/GraphicsEngine.cpp	2012-11-28 15:16:41 +0000
+++ NuxGraphics/GraphicsEngine.cpp	2013-01-21 12:52:20 +0000
@@ -1335,6 +1335,48 @@
     SetViewport(0, 0, width, height);
     Push2DWindow(width, height);
   }
+  
+  /*! Description - This function calculates position offsets for our gaussian weight values to utilise the GPU bilinear sampling
+   *                which gets neighbouring pixel's data in just one sample. This serves to halve the loop for both vertical and
+   *                horizontal blur shaders.
+   *  Params -      First two parameters are the weight and weight offsets which are passed as uniforms to our shader.
+   *                our sigma dictates how strong our blur will be.
+   *  Return -      We return our loop count which is a #define in our vertical and horizontal shaders.
+   */
+  int GraphicsEngine::LinearSampleGaussianWeights(std::vector<float>& weights, std::vector<float>& offsets, 
+                                                  float sigma)
+  {
+    //Calculate our support which is used as our loop count.
+    int support = int(sigma * 3.0f);
+    
+    weights.push_back(exp(-(0*0)/(2*sigma*sigma))/(sqrt(2*constants::pi)*sigma));
+    
+    float total = weights.back();
+    
+    //Our first weight has an offset of 0.
+    offsets.push_back(0);
+    
+    for (int i = 1; i <= support; i++)
+    {
+      float w1 = exp(-(i*i)/(2*sigma*sigma))/(sqrt(2*constants::pi)*sigma);
+      float w2 = exp(-((i+1)*(i+1))/(2*sigma*sigma))/(sqrt(2*constants::pi)*sigma);
+      
+      weights.push_back(w1 + w2);
+      total += 2.0f * weights[i];
+      
+      //Calculate our offset to utilise our GPU's bilinear sampling capability. By sampling in between texel we get the data of
+      //neighbouring pixels with only one sample.
+      offsets.push_back((i * w1 + (i + 1) * w2) / weights[i]);
+    }
+    
+    //Normalise our weights.
+    for (int i = 0; i < support; i++)
+    {
+      weights[i] /= total;
+    }
+    
+    return support;
+  }
 
   void GraphicsEngine::GaussianWeights(float **weights, float sigma, unsigned int num_tap)
   {

=== modified file 'NuxGraphics/GraphicsEngine.h'
--- NuxGraphics/GraphicsEngine.h	2012-11-12 20:59:56 +0000
+++ NuxGraphics/GraphicsEngine.h	2013-01-21 12:52:20 +0000
@@ -434,6 +434,8 @@
     void QRP_GLSL_VerticalGauss   (int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform, const Color& c0, float sigma = 1.0f);
     void QRP_GLSL_HorizontalHQGauss(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform, const Color& c0, float sigma = 1.0f);
     void QRP_GLSL_VerticalHQGauss   (int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform, const Color& c0, float sigma = 1.0f);
+    void QRP_GLSL_HorizontalLSGauss(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform, const Color& c0, float sigma = 1.0f);
+    void QRP_GLSL_VerticalLSGauss   (int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform, const Color& c0, float sigma = 1.0f);
     void QRP_GLSL_ColorMatrix     (int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform, const Color& c0, Matrix4 color_matrix, Vector4 offset);
 
     /*!
@@ -450,6 +452,13 @@
       ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform,
       const Color& c0,
       float sigma = 1.0f, int num_pass = 1);
+    
+    ObjectPtr<IOpenGLBaseTexture> QRP_GLSL_GetLSBlurTexture(
+      int x, int y,
+      int buffer_width, int buffer_height,
+      ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform,
+      const Color& c0,
+      float sigma = 1.0f, int num_pass = 1);
 
     ObjectPtr<IOpenGLBaseTexture> QRP_GLSL_GetAlphaTexture(
       ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm& texxform,
@@ -480,6 +489,12 @@
       int buffer_width, int buffer_height,
       FxStructure* fx_structure, TexCoordXForm& texxform,
       const Color& c0, float sigma = 1.0f, int num_pass = 1);
+    
+   void QRP_GLSL_GetLSBlurFx(
+    int x, int y,
+    int buffer_width, int buffer_height,
+    FxStructure *fx_structure, TexCoordXForm &texxform,
+    const Color& c0, float sigma = 1.0f, int num_pass = 1);
 
     void QRP_GLSL_DisturbedTexture(
       int x, int y, int width, int height,
@@ -842,6 +857,9 @@
 
     //! Helper function to compute a Gaussian filter weights
     void GaussianWeights(float **weights, float sigma, unsigned int num_tap);
+    
+    int LinearSampleGaussianWeights(std::vector<float>& weights, std::vector<float>& offsets, 
+                                                  float sigma);
 
     //! Helper function to set an fbo
     void SetFrameBufferHelper(
@@ -1009,6 +1027,14 @@
     void InitSLVerticalHQGaussFilter(int sigma);
     //! Gauss vertical filter.
     ObjectPtr<IOpenGLShaderProgram> _vertical_hq_gauss_filter_prog[NUX_MAX_GAUSSIAN_SIGMA];
+    
+    void InitSLHorizontalLSGaussFilter(int k);
+    //! Gauss horizontal filter.
+    ObjectPtr<IOpenGLShaderProgram> _horizontal_ls_gauss_filter_prog[NUX_MAX_GAUSSIAN_SIGMA];
+
+    void InitSLVerticalLSGaussFilter(int k);
+    //! Gauss vertical filter.
+    ObjectPtr<IOpenGLShaderProgram> _vertical_ls_gauss_filter_prog[NUX_MAX_GAUSSIAN_SIGMA];
 
     void InitSLColorMatrixFilter();
     //! Color matrix filter.

=== modified file 'NuxGraphics/RenderingPipeGLSL.cpp'
--- NuxGraphics/RenderingPipeGLSL.cpp	2012-11-12 20:59:56 +0000
+++ NuxGraphics/RenderingPipeGLSL.cpp	2013-01-21 12:52:20 +0000
@@ -629,6 +629,118 @@
     CHECKGL(glBindAttribLocation(_vertical_hq_gauss_filter_prog[k-1]->GetOpenGLID(), 0, "AVertex"));
     _vertical_hq_gauss_filter_prog[k-1]->Link();
   }
+  
+  void GraphicsEngine::InitSLHorizontalLSGaussFilter(int k)
+  {
+    if (_horizontal_ls_gauss_filter_prog[k-1].IsValid())
+    {
+      // Shader program already compiled
+      return;
+    }
+
+    ObjectPtr<IOpenGLVertexShader> vs = _graphics_display.m_DeviceFactory->CreateVertexShader();
+    ObjectPtr<IOpenGLPixelShader> ps = _graphics_display.m_DeviceFactory->CreatePixelShader();
+
+    std::string vs_string = NUX_VERTEX_SHADER_HEADER
+    "uniform mat4 view_projection_matrix;               \n\
+     attribute vec4 vertex;                             \n\
+     attribute vec4 tex_coord;                          \n\
+     varying vec4 v_tex_coord;                          \n\
+     void main()                                        \n\
+     {                                                  \n\
+      v_tex_coord = tex_coord;                          \n\
+      gl_Position = view_projection_matrix * vertex;    \n\
+     }";
+
+    std::string ps_string = NUX_FRAGMENT_SHADER_HEADER
+    "varying vec4 v_tex_coord;                                                                                  \n\
+     uniform sampler2D tex_object;                                                                              \n\
+     uniform vec2 tex_size;                                                                                     \n\
+     #define NUM_SAMPLES %d                                                                                     \n\
+     uniform float weights[NUM_SAMPLES];                                                                        \n\
+     uniform float offsets[NUM_SAMPLES];                                                                        \n\
+     void main()                                                                                                \n\
+     {                                                                                                          \n\
+      vec3 acc = texture2D(tex_object, v_tex_coord.st).rgb*weights[0];\n\
+      for (int i = 1; i < NUM_SAMPLES; i++)                                                                     \n\
+      {                                                                                                         \n\
+        acc += texture2D(tex_object, (v_tex_coord.st+(vec2(offsets[i], 0.0)/tex_size))).rgb*weights[i]; \n\
+        acc += texture2D(tex_object, (v_tex_coord.st-(vec2(offsets[i], 0.0)/tex_size))).rgb*weights[i]; \n\
+      }                                                                                                         \n\
+      gl_FragColor = vec4(acc, 1.0);                                                                    \n\
+     }";
+
+    int l = ps_string.length();
+    char* shader_prog = new char[l+10];
+    sprintf(shader_prog, ps_string.c_str(), k);
+
+    _horizontal_ls_gauss_filter_prog[k-1] = _graphics_display.m_DeviceFactory->CreateShaderProgram();
+    vs->SetShaderCode(vs_string.c_str());
+    ps->SetShaderCode(shader_prog);
+    delete[] shader_prog;
+
+    _horizontal_ls_gauss_filter_prog[k-1]->ClearShaderObjects();
+    _horizontal_ls_gauss_filter_prog[k-1]->AddShaderObject(vs);
+    _horizontal_ls_gauss_filter_prog[k-1]->AddShaderObject(ps);
+    CHECKGL(glBindAttribLocation(_horizontal_ls_gauss_filter_prog[k-1]->GetOpenGLID(), 0, "vertex"));
+    _horizontal_ls_gauss_filter_prog[k-1]->Link();
+  }
+
+  void GraphicsEngine::InitSLVerticalLSGaussFilter(int k)
+  {
+    if (_vertical_ls_gauss_filter_prog[k-1].IsValid())
+    {
+      // Shader program already compiled
+      return;
+    }
+
+    ObjectPtr<IOpenGLVertexShader> vs = _graphics_display.m_DeviceFactory->CreateVertexShader();
+    ObjectPtr<IOpenGLPixelShader> ps = _graphics_display.m_DeviceFactory->CreatePixelShader();
+
+    std::string vs_string = NUX_VERTEX_SHADER_HEADER
+    "uniform mat4 view_projection_matrix;               \n\
+     attribute vec4 vertex;                             \n\
+     attribute vec4 tex_coord;                          \n\
+     varying vec4 v_tex_coord;                          \n\
+     void main()                                        \n\
+     {                                                  \n\
+      v_tex_coord = tex_coord;                          \n\
+      gl_Position = view_projection_matrix * vertex;    \n\
+     }";
+
+    std::string ps_string = NUX_FRAGMENT_SHADER_HEADER
+    "varying vec4 v_tex_coord;                                                                                  \n\
+     uniform sampler2D tex_object;                                                                              \n\
+     uniform vec2 tex_size;                                                                                     \n\
+     #define NUM_SAMPLES %d                                                                                     \n\
+     uniform float weights[NUM_SAMPLES];                                                                        \n\
+     uniform float offsets[NUM_SAMPLES];                                                                        \n\
+     void main()                                                                                                \n\
+     {                                                                                                          \n\
+      vec3 acc = texture2D(tex_object, v_tex_coord.st).rgb*weights[0]; \n\
+      for (int i = 1; i < NUM_SAMPLES; i++)                                                                     \n\
+      {                                                                                                         \n\
+        acc += texture2D(tex_object, (v_tex_coord.st+(vec2(0.0, offsets[i])/tex_size))).rgb*weights[i]; \n\
+        acc += texture2D(tex_object, (v_tex_coord.st-(vec2(0.0, offsets[i])/tex_size))).rgb*weights[i]; \n\
+      }                                                                                                         \n\
+      gl_FragColor = vec4(acc, 1.0);                                                                    \n\
+     }";
+
+    int l = ps_string.length();
+    char* shader_prog = new char[l+10];
+    sprintf(shader_prog, ps_string.c_str(), k);
+
+    _vertical_ls_gauss_filter_prog[k-1] = _graphics_display.m_DeviceFactory->CreateShaderProgram();
+    vs->SetShaderCode(vs_string.c_str());
+    ps->SetShaderCode(shader_prog);
+    delete[] shader_prog;
+
+    _vertical_ls_gauss_filter_prog[k-1]->ClearShaderObjects();
+    _vertical_ls_gauss_filter_prog[k-1]->AddShaderObject(vs);
+    _vertical_ls_gauss_filter_prog[k-1]->AddShaderObject(ps);
+    CHECKGL(glBindAttribLocation(_vertical_ls_gauss_filter_prog[k-1]->GetOpenGLID(), 0, "vertex"));
+    _vertical_ls_gauss_filter_prog[k-1]->Link();
+  }
 
   void GraphicsEngine::InitSLColorMatrixFilter()
   {
@@ -1982,6 +2094,155 @@
 
     ShaderProg->End();
   }
+  
+  void GraphicsEngine::QRP_GLSL_HorizontalLSGauss(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform0, const Color & /* c0 */, float sigma)
+  {
+    std::vector<float> weights(0);
+    std::vector<float> offsets(0);
+    
+    int num_samples = LinearSampleGaussianWeights(weights, offsets, sigma);
+
+    if (_horizontal_ls_gauss_filter_prog[num_samples-1].IsValid() == false)
+    {
+      InitSLHorizontalLSGaussFilter(num_samples);
+    }
+
+    m_quad_tex_stats++;
+    QRP_Compute_Texture_Coord(width, height, device_texture, texxform0);
+    float fx = x, fy = y;
+    float vtx_buffer[] =
+    {
+      fx,          fy,          0.0f, 1.0f, texxform0.u0, texxform0.v0, 0, 0,
+      fx,          fy + height, 0.0f, 1.0f, texxform0.u0, texxform0.v1, 0, 0,
+      fx + width,  fy + height, 0.0f, 1.0f, texxform0.u1, texxform0.v1, 0, 0,
+      fx + width,  fy,          0.0f, 1.0f, texxform0.u1, texxform0.v0, 0, 0,
+    };
+
+    ObjectPtr<IOpenGLShaderProgram> shader_prog;
+
+    if (!device_texture->Type().IsDerivedFromType(IOpenGLTexture2D::StaticObjectType))
+    {
+      return;
+    }
+
+    shader_prog = _horizontal_ls_gauss_filter_prog[num_samples-1];
+
+    CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
+    CHECKGL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
+    shader_prog->Begin();
+
+    int tex_object_location     = shader_prog->GetUniformLocationARB("tex_object");
+    int weights_location        = shader_prog->GetUniformLocationARB("weights");
+    int offsets_location        = shader_prog->GetUniformLocationARB("offsets");
+    int tex_size_location       = shader_prog->GetUniformLocationARB("tex_size");
+    int vertex_location         = shader_prog->GetAttributeLocation("vertex");
+    int tex_coord_location      = shader_prog->GetAttributeLocation("tex_coord");
+
+    SetTexture(GL_TEXTURE0, device_texture);
+    CHECKGL(glUniform1iARB(tex_object_location, 0));
+
+    CHECKGL(glUniform1fv(weights_location, weights.size(), &weights[0]));
+    CHECKGL(glUniform1fv(offsets_location, offsets.size(), &offsets[0]));
+
+    CHECKGL(glUniform2fARB(tex_size_location, width, height));
+
+    int     VPMatrixLocation = shader_prog->GetUniformLocationARB("view_projection_matrix");
+    Matrix4 MVPMatrix = GetOpenGLModelViewProjectionMatrix();
+    shader_prog->SetUniformLocMatrix4fv((GLint) VPMatrixLocation, 1, false, (GLfloat *) & (MVPMatrix.m));
+
+    CHECKGL(glEnableVertexAttribArrayARB(vertex_location));
+    CHECKGL(glVertexAttribPointerARB((GLuint) vertex_location, 4, GL_FLOAT, GL_FALSE, 32, vtx_buffer));
+
+    if (tex_coord_location != -1)
+    {
+      CHECKGL(glEnableVertexAttribArrayARB(tex_coord_location));
+      CHECKGL(glVertexAttribPointerARB((GLuint) tex_coord_location, 4, GL_FLOAT, GL_FALSE, 32, vtx_buffer + 4));
+    }
+
+    CHECKGL(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
+
+    CHECKGL(glDisableVertexAttribArrayARB(vertex_location));
+
+    if (tex_coord_location != -1)
+      CHECKGL(glDisableVertexAttribArrayARB(tex_coord_location));
+
+    shader_prog->End();
+  }
+
+  void GraphicsEngine::QRP_GLSL_VerticalLSGauss(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform0, const Color & /* c0 */, float sigma)
+  {
+    std::vector<float> weights(0);
+    std::vector<float> offsets(0);
+    
+    int num_samples = LinearSampleGaussianWeights(weights, offsets, sigma);
+
+    if (_vertical_ls_gauss_filter_prog[num_samples-1].IsValid() == false)
+    {
+      InitSLVerticalLSGaussFilter(num_samples);
+    }
+
+    m_quad_tex_stats++;
+    QRP_Compute_Texture_Coord(width, height, device_texture, texxform0);
+    float fx = x, fy = y;
+    float vtx_buffer[] =
+    {
+      fx,          fy,          0.0f, 1.0f, texxform0.u0, texxform0.v0, 0, 0,
+      fx,          fy + height, 0.0f, 1.0f, texxform0.u0, texxform0.v1, 0, 0,
+      fx + width,  fy + height, 0.0f, 1.0f, texxform0.u1, texxform0.v1, 0, 0,
+      fx + width,  fy,          0.0f, 1.0f, texxform0.u1, texxform0.v0, 0, 0,
+    };
+
+    ObjectPtr<IOpenGLShaderProgram> shader_prog;
+
+    if (!device_texture->Type().IsDerivedFromType(IOpenGLTexture2D::StaticObjectType))
+    {
+      return;
+    }
+
+    shader_prog = _vertical_ls_gauss_filter_prog[num_samples-1];
+
+    CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
+    CHECKGL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
+    shader_prog->Begin();
+
+    int tex_object_location     = shader_prog->GetUniformLocationARB("tex_object");
+    int weights_location        = shader_prog->GetUniformLocationARB("weights");
+    int offsets_location        = shader_prog->GetUniformLocationARB("offsets");
+    int tex_size_location       = shader_prog->GetUniformLocationARB("tex_size");
+    int vertex_location         = shader_prog->GetAttributeLocation("vertex");
+    int tex_coord_location      = shader_prog->GetAttributeLocation("tex_coord");
+
+    SetTexture(GL_TEXTURE0, device_texture);
+
+    CHECKGL(glUniform1iARB(tex_object_location, 0));
+
+    CHECKGL(glUniform1fv(weights_location, weights.size(), &weights[0]));
+    CHECKGL(glUniform1fv(offsets_location, offsets.size(), &offsets[0]));
+
+    CHECKGL(glUniform2fARB(tex_size_location, width, height));
+
+    int     VPMatrixLocation = shader_prog->GetUniformLocationARB("view_projection_matrix");
+    Matrix4 MVPMatrix = GetOpenGLModelViewProjectionMatrix();
+    shader_prog->SetUniformLocMatrix4fv((GLint) VPMatrixLocation, 1, false, (GLfloat *) & (MVPMatrix.m));
+
+    CHECKGL(glEnableVertexAttribArrayARB(vertex_location));
+    CHECKGL(glVertexAttribPointerARB((GLuint) vertex_location, 4, GL_FLOAT, GL_FALSE, 32, vtx_buffer));
+
+    if (tex_coord_location != -1)
+    {
+      CHECKGL(glEnableVertexAttribArrayARB(tex_coord_location));
+      CHECKGL(glVertexAttribPointerARB((GLuint) tex_coord_location, 4, GL_FLOAT, GL_FALSE, 32, vtx_buffer + 4));
+    }
+
+    CHECKGL(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
+
+    CHECKGL(glDisableVertexAttribArrayARB(vertex_location));
+
+    if (tex_coord_location != -1)
+      CHECKGL(glDisableVertexAttribArrayARB(tex_coord_location));
+
+    shader_prog->End();
+  }
 
   void GraphicsEngine::QRP_GLSL_ColorMatrix(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform0,
     const Color &c0,
@@ -2133,6 +2394,72 @@
 
     return _offscreen_color_rt0;
   }
+  
+  ObjectPtr<IOpenGLBaseTexture> GraphicsEngine::QRP_GLSL_GetLSBlurTexture(
+    int x, int y,
+    int buffer_width, int buffer_height,
+    ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform,
+    const Color& c0,
+    float sigma, int num_pass)
+  {
+    int quad_width = device_texture->GetWidth();
+    int quad_height = device_texture->GetHeight();
+
+    num_pass = Clamp<int> (num_pass, 1, 50);
+
+    ObjectPtr<IOpenGLFrameBufferObject> prevFBO = GetGraphicsDisplay()->GetGpuDevice()->GetCurrentFrameBufferObject();
+    int previous_width = 0;
+    int previous_height = 0;
+    if (prevFBO.IsValid())
+    {
+      previous_width = prevFBO->GetWidth();
+      previous_height = prevFBO->GetHeight();
+    }
+    else
+    {
+      previous_width = _graphics_display.GetWindowWidth();
+      previous_height = _graphics_display.GetWindowHeight();
+    }
+
+    CHECKGL(glClearColor(0, 0, 0, 0));
+    _offscreen_color_rt0->SetWrap(GL_CLAMP, GL_CLAMP, GL_CLAMP);
+    _offscreen_color_rt0->SetFiltering(GL_NEAREST, GL_NEAREST);
+    _offscreen_color_rt1->SetWrap(GL_CLAMP, GL_CLAMP, GL_CLAMP);
+    _offscreen_color_rt1->SetFiltering(GL_NEAREST, GL_NEAREST);
+
+    SetFrameBufferHelper(_offscreen_fbo, _offscreen_color_rt0, _offscreen_depth_rt0, buffer_width, buffer_height);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+    QRP_GLSL_1Tex(x, y, quad_width, quad_height, device_texture, texxform, color::White);
+
+    TexCoordXForm texxform1;
+    for (int i = 0; i < num_pass; i++)
+    {
+      SetFrameBufferHelper(_offscreen_fbo, _offscreen_color_rt1, _offscreen_depth_rt1, buffer_width, buffer_height);
+      glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+      QRP_GLSL_HorizontalLSGauss(0, 0, buffer_width, buffer_height, _offscreen_color_rt0, texxform1, c0, sigma);
+
+      SetFrameBufferHelper(_offscreen_fbo, _offscreen_color_rt0, _offscreen_depth_rt0, buffer_width, buffer_height);
+      glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+      QRP_GLSL_VerticalLSGauss(0, 0, buffer_width, buffer_height, _offscreen_color_rt1, texxform1, c0, sigma);
+    }
+
+    _offscreen_fbo->Deactivate();
+
+    if (prevFBO.IsValid())
+    {
+      prevFBO->Activate(true);
+      SetViewport(0, 0, previous_width, previous_height);
+      SetOrthographicProjectionMatrix(previous_width, previous_height);
+    }
+    else
+    {
+      SetViewport(0, 0, previous_width, previous_height);
+      SetOrthographicProjectionMatrix(previous_width, previous_height);
+    }
+
+    return _offscreen_color_rt0;
+  }
 
   ObjectPtr<IOpenGLBaseTexture> GraphicsEngine::QRP_GLSL_GetPower(
     ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform, const Color &c0, const Vector4 &exponent)
@@ -2469,11 +2796,76 @@
     {
       SetFrameBufferHelper(_offscreen_fbo, fx_structure->temp_texture, _offscreen_depth_rt1, buffer_width, buffer_height);
       glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-      QRP_GLSL_HorizontalHQGauss(0, 0, buffer_width, buffer_height, fx_structure->dst_texture, texxform1, c0, sigma);
-
-      SetFrameBufferHelper(_offscreen_fbo, fx_structure->dst_texture, _offscreen_depth_rt0, buffer_width, buffer_height);
-      glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-      QRP_GLSL_VerticalHQGauss(0, 0, buffer_width, buffer_height, fx_structure->temp_texture, texxform1, c0, sigma);
+      QRP_GLSL_HorizontalGauss(0, 0, buffer_width, buffer_height, fx_structure->dst_texture, texxform1, c0, sigma);
+
+      SetFrameBufferHelper(_offscreen_fbo, fx_structure->dst_texture, _offscreen_depth_rt0, buffer_width, buffer_height);
+      glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+      QRP_GLSL_VerticalGauss(0, 0, buffer_width, buffer_height, fx_structure->temp_texture, texxform1, c0, sigma);
+    }
+
+    _offscreen_fbo->Deactivate();
+
+    if (prevFBO.IsValid())
+    {
+      prevFBO->Activate(true);
+      SetViewport(0, 0, previous_width, previous_height);
+      SetOrthographicProjectionMatrix(previous_width, previous_height);
+    }
+    else
+    {
+      SetViewport(0, 0, previous_width, previous_height);
+      SetOrthographicProjectionMatrix(previous_width, previous_height);
+    }
+  }
+  
+  void GraphicsEngine::QRP_GLSL_GetLSBlurFx(
+    int x, int y,
+    int buffer_width, int buffer_height,
+    FxStructure *fx_structure, TexCoordXForm &texxform,
+    const Color& c0, float sigma, int num_pass)
+  {
+    int quad_width = fx_structure->src_texture->GetWidth();
+    int quad_height = fx_structure->src_texture->GetHeight();
+
+    num_pass = Clamp<int> (num_pass, 1, 50);
+
+    ObjectPtr<IOpenGLFrameBufferObject> prevFBO = GetGraphicsDisplay()->GetGpuDevice()->GetCurrentFrameBufferObject();
+    int previous_width = 0;
+    int previous_height = 0;
+    if (prevFBO.IsValid())
+    {
+      previous_width = prevFBO->GetWidth();
+      previous_height = prevFBO->GetHeight();
+    }
+    else
+    {
+      previous_width = _graphics_display.GetWindowWidth();
+      previous_height = _graphics_display.GetWindowHeight();
+    }
+
+    CHECKGL(glClearColor(0, 0, 0, 0));
+    fx_structure->src_texture->SetWrap(GL_CLAMP, GL_CLAMP, GL_CLAMP);
+    fx_structure->src_texture->SetFiltering(GL_NEAREST, GL_NEAREST);
+    fx_structure->dst_texture->SetWrap(GL_CLAMP, GL_CLAMP, GL_CLAMP);
+    fx_structure->dst_texture->SetFiltering(GL_NEAREST, GL_NEAREST);
+    fx_structure->temp_texture->SetWrap(GL_CLAMP, GL_CLAMP, GL_CLAMP);
+    fx_structure->temp_texture->SetFiltering(GL_NEAREST, GL_NEAREST);
+
+    SetFrameBufferHelper(_offscreen_fbo, fx_structure->dst_texture, _offscreen_depth_rt0, buffer_width, buffer_height);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+    QRP_GLSL_1Tex(x, y, quad_width, quad_height, fx_structure->src_texture, texxform, color::White);
+
+    TexCoordXForm texxform1;
+    for (int i = 0; i < num_pass; i++)
+    {
+      SetFrameBufferHelper(_offscreen_fbo, fx_structure->temp_texture, _offscreen_depth_rt1, buffer_width, buffer_height);
+      glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+      QRP_GLSL_HorizontalLSGauss(0, 0, buffer_width, buffer_height, fx_structure->dst_texture, texxform1, c0, sigma);
+
+      SetFrameBufferHelper(_offscreen_fbo, fx_structure->dst_texture, _offscreen_depth_rt0, buffer_width, buffer_height);
+      glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+      QRP_GLSL_VerticalLSGauss(0, 0, buffer_width, buffer_height, fx_structure->temp_texture, texxform1, c0, sigma);
     }
 
     _offscreen_fbo->Deactivate();