Meanwhile i tried (for some time, if i’m honest) to do a good deblur setup. Until recently i lacked a proper aa shader and deblur had it’s issues, but i managed to resolve them now.

I’m posting the shader/preset if anyone cares to try it out.

Here is a comparison with the above preset agains deblured:

http://screenshotcomparison.com/comparison/119330

deblur.glsl (goes in deblur/shaders/)

```
/*
Deblur Shader
Copyright (C) 2005 - 2018 guest(r) - guest.r@gmail.com
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#pragma parameter OFFSET "Deblur offset" 2.0 1.0 4.0 0.25
#pragma parameter DEBLUR "Deblur str. " 2.5 1.0 7.0 0.25
#pragma parameter SMART "Smart deblur " 0.0 0.0 1.0 1.00
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
vec4 _oPosition1;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
// compatibility #defines
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
void main()
{
gl_Position = MVPMatrix * VertexCoord;
TEX0.xy = TexCoord.xy * 1.00001;
}
#elif defined(FRAGMENT)
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out COMPAT_PRECISION vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
// compatibility #defines
#define Source Texture
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
#ifdef PARAMETER_UNIFORM
uniform COMPAT_PRECISION float OFFSET;
uniform COMPAT_PRECISION float DEBLUR;
uniform COMPAT_PRECISION float SMART;
#else
#define OFFSET 2.0
#define DEBLUR 2.5
#define SMART 0.0
#endif
vec3 dt = vec3(1.,1.,1.);
vec3 dtt = vec3(0.0001, 0.0001, 0.0001);
void main()
{
vec2 tex = vTexCoord;
vec2 texsize = SourceSize.xy;
float dx = OFFSET/texsize.x;
float dy = OFFSET/texsize.y;
vec4 yx = vec4( dx, dy,-dx,-dy);
vec2 xx = vec2( dx, 0.0);
vec2 yy = vec2( 0.0, dy);
vec3 c11 = COMPAT_TEXTURE(Source, tex ).xyz;
vec3 c00 = COMPAT_TEXTURE(Source, tex + yx.zw).xyz;
vec3 c20 = COMPAT_TEXTURE(Source, tex + yx.xw).xyz;
vec3 c22 = COMPAT_TEXTURE(Source, tex + yx.xy).xyz;
vec3 c02 = COMPAT_TEXTURE(Source, tex + yx.zy).xyz;
vec3 c10 = COMPAT_TEXTURE(Source, tex - yy ).xyz;
vec3 c21 = COMPAT_TEXTURE(Source, tex + xx ).xyz;
vec3 c12 = COMPAT_TEXTURE(Source, tex + yy ).xyz;
vec3 c01 = COMPAT_TEXTURE(Source, tex - xx ).xyz;
vec3 mn1 = min (min (c00,c01),c02);
vec3 mn2 = min (min (c10,c11),c12);
vec3 mn3 = min (min (c20,c21),c22);
vec3 mx1 = max (max (c00,c01),c02);
vec3 mx2 = max (max (c10,c11),c12);
vec3 mx3 = max (max (c20,c21),c22);
vec3 d11;
mn1 = min(min(mn1,mn2),mn3);
mx1 = max(max(mx1,mx2),mx3);
vec3 dif1 = abs(c11-mn1) + dtt;
vec3 dif2 = abs(c11-mx1) + dtt;
float DB1 = DEBLUR; float dif;
if (SMART == 1.0)
{
dif = max(length(dif1),length(dif2));
dif = min(dif, 1.0);
DB1 = max(mix(-0.5, DEBLUR, dif), 1.0);
}
dif1=vec3(pow(dif1.x,DB1),pow(dif1.y,DB1),pow(dif1.z,DB1));
dif2=vec3(pow(dif2.x,DB1),pow(dif2.y,DB1),pow(dif2.z,DB1));
d11 = vec3((dif1.x*mx1.x + dif2.x*mn1.x)/(dif1.x + dif2.x),
(dif1.y*mx1.y + dif2.y*mn1.y)/(dif1.y + dif2.y),
(dif1.z*mx1.z + dif2.z*mn1.z)/(dif1.z + dif2.z));
float k10 = 1.0/(dot(abs(c10-d11),dt)+0.0001);
float k01 = 1.0/(dot(abs(c01-d11),dt)+0.0001);
float k11 = 1.0/(dot(abs(c11-d11),dt)+0.0001);
float k21 = 1.0/(dot(abs(c21-d11),dt)+0.0001);
float k12 = 1.0/(dot(abs(c12-d11),dt)+0.0001);
c11 = (k10*c10 + k01*c01 + k11*c11 + k21*c21 + k12*c12)/(k10+k01+k11+k21+k12);
FragColor = vec4(c11,1.0);
}
#endif
```

Has some options and can even do smart deblur, like the 4xsoftSdB.

The preset is like above (the hybrid really doesen’t produce bad shapes):

xsoft+scalefx-hybrid+level2aa-sharp.glslp

```
shaders = 9
shader0 = ../scalefx/shaders/scalefx-pass0.glsl
filter_linear0 = false
scale_type0 = source
scale0 = 1.0
float_framebuffer0 = true
shader1 = ../scalefx/shaders/scalefx-pass1.glsl
filter_linear1 = false
scale_type1 = source
scale1 = 1.0
float_framebuffer1 = true
shader2 = ../scalefx/shaders/scalefx-pass2.glsl
filter_linear2 = false
scale_type2 = source
scale2 = 1.0
shader3 = ../scalefx/shaders/scalefx-pass3.glsl
filter_linear3 = false
scale_type3 = source
scale3 = 1.0
shader4 = ../scalefx/shaders/scalefx-pass4-hybrid.glsl
filter_linear4 = false
scale_type4 = source
scale4 = 3.0
shader5 = ../stock.glsl
filter_linear5 = false
scale_type5 = source
scale5 = 2.0
shader6 = ../anti-aliasing/shaders/aa-shader-4.0-level2/aa-shader-4.0-level2-pass1-noblend.glsl
filter_linear6 = true
scale_type6 = source
scale6 = 1.0
shader7 = ../anti-aliasing/shaders/aa-shader-4.0-level2/aa-shader-4.0-level2-pass2.glsl
filter_linear7 = true
scale_type7 = source
scale7 = 1.0
shader8 = ../deblur/shaders/deblur.glsl
filter_linear8 = true
scale_type8 = source
scale8 = 1.0
parameters = "SFX_CLR;SFX_SAA"
SFX_SAA = 0.00
SFX_CLR = 0.60
```

Now i’m off to grind some rep.

Edit: Much better smart version (option) of deblur.