CODEWITHSUNDEEP
openglglslhlslfragment-shader
jmasterx
jmasterx

Reputation: 54113

GLSL Shader Ported From HLSL Is Not Working

I have this HLSL Shader for blur:

   struct VS_INPUT
   {
      float4 Position  : POSITION0;
      float2 TexCoord  : TEXCOORD0;
      float4 Color     : TEXCOORD1;
   };
   struct VS_OUTPUT
   {
      float4 Position  : POSITION0;
      float4 Color     : COLOR0;
      float2 TexCoord  : TEXCOORD0;
   };

   float4x4 al_projview_matrix;

   VS_OUTPUT vs_main(VS_INPUT Input)
   {
      VS_OUTPUT Output;
      Output.Position = mul(Input.Position, al_projview_matrix);
      Output.Color = Input.Color;
      Output.TexCoord = Input.TexCoord;
      return Output;
   }

Frag 

texture al_tex;
   sampler2D s = sampler_state {
      texture = <al_tex>;
   };

   int tWidth;
   int tHeight;
   float blurSize = 5.0;
   float4 ps_main(VS_OUTPUT Input) : COLOR0
   {
      float2 pxSz = float2(1.0 / tWidth,1.0 / tHeight);
      float4 outC = 0;
      float outA = 0;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,-4.0 * pxSz.y * blurSize)).a * 0.05;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,-3.0 * pxSz.y * blurSize)).a * 0.09;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,-2.0 * pxSz.y * blurSize)).a * 0.12;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,-pxSz.y * blurSize)).a * 0.15;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,0)).a * 0.16;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,pxSz.y * blurSize)).a * 0.15;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,2.0 * pxSz.y * blurSize)).a * 0.12;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,3.0 * pxSz.y * blurSize)).a * 0.09;
      outA += Input.Color.a * tex2D(s, Input.TexCoord.xy + float2(0,4.0 * pxSz.y * blurSize)).a * 0.05;

     outC.a = outA;
      return outC;
   }

There is a similar one for horizontal...

The idea is, I provide tWidth, tHeight for the texture with and height, and use that to get the 'size' of a pixel relative to UV coords.

I then use this to do normal blur by taking a weighted average of neighbors.

I ported this to GLSL:

attribute vec4 al_pos;
attribute vec4 al_color;
attribute vec2 al_texcoord;
uniform mat4 al_projview_matrix;
varying vec4 varying_color;
varying vec2 varying_texcoord;
void main()
{
   varying_color = al_color;
   varying_texcoord = al_texcoord;
   gl_Position = al_projview_matrix * al_pos;
}

Frag

uniform sampler2D al_tex;
varying float blurSize;
varying float tWidth;
varying float tHeight;
varying vec2 varying_texcoord;
varying vec4 varying_color;
void main()
{
    vec4 sum = vec4(0.0);
    vec2 pxSz = vec2(1.0 / tWidth,1.0 / tHeight);
    // blur in x
    // take nine samples, with the distance blurSize between them
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,-4.0 * pxSz.y * blurSize))* 0.05;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,-3.0 * pxSz.y * blurSize))* 0.09;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,-2.0 * pxSz.y * blurSize))* 0.12;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,-pxSz.y * blurSize))* 0.15;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,0))* 0.16;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,pxSz.y * blurSize))* 0.15;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,2.0 * pxSz.y * blurSize))* 0.12;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,3.0 * pxSz.y * blurSize))* 0.09;
    sum += texture2D(al_tex, varying_texcoord.xy + vec2(0,4.0 * pxSz.y * blurSize))* 0.05;
    gl_FragColor = varying_color * sum;
}

This is a little different, but it's the same logic. I convert pixel coords to UV coords, and multiply by the blur factor, same as the hlsl factor. Yet, the glsl one gives me an unblurred, slightly more transparent version of the original.

What could cause this?

Upvotes: 0

Views: 674

Answers (1)

derhass
derhass

Reputation: 45332

In your fragment shader, you have:

varying vec4 varying_color;
[...]
     gl_FragColor = varying_color;

so all the texture fetches and calculations you do don't have any effect on the final shader output (and are likely to be completely removed by the compiler). You probably want to output sum or to modify it, e.g. with gl_FragColor = varying_color * sum; or whatever effect you want to achieve.

Another thing: in the frag shader, you define varyings for the texture size, but you don't pass them from the vertex shader. Those should be uniforms (or, in modern GLSL, there is also the textureSize() GLSL function which allows you to directly sccess that values without explicitely passing them).

Upvotes: 1

Related Questions