Blur Con Pixel Shaders

[Helius]

 Hola,

Estoy tratando de hacer blur mediante shaders para después utilizarlo en glow o specular bloom pero no consigo que me salga del todo bien.

El único problema que tengo es que por la derecha de la imagen siempre se me generan una lineas estiradas que no se de dónde salen... y sólo se generan por la derecha. Incluso si sólo hago la pasada de blur vertical (que sólo toma lecturas de coordenadas de textura en vertical) también me aparecen. Parece como que se estiren los últimos pixels de la derecha por toda la pantalla, pero insisto si muevo el cubo ese al borde izquierdo no suce nada malo  :blink:

¿¿Alguna idea??

Una foto:


Saludos.

[Lord Trancos 2]

 Si pones el código del shader, mejor q mejor.

Te pongo el que yo uso (no recuerdo de donde lo saque).

Código [Seleccionar] Expand


uniform float sampleDist;
uniform sampler2D RT;
varying vec2 vTexCoord;

void main(void)
{
  vec2 samples00 = vec2(-0.326212, -0.405805);
  vec2 samples01 = vec2(-0.840144, -0.073580);
  vec2 samples02 = vec2(-0.695914,  0.457137);
  vec2 samples03 = vec2(-0.203345,  0.620716);
  vec2 samples04 = vec2( 0.962340, -0.194983);
  vec2 samples05 = vec2( 0.473434, -0.480026);
  vec2 samples06 = vec2( 0.519456,  0.767022);
  vec2 samples07 = vec2( 0.185461, -0.893124);
  vec2 samples08 = vec2( 0.507431,  0.064425);
  vec2 samples09 = vec2( 0.896420,  0.412458);
  vec2 samples10 = vec2(-0.321940, -0.932615);
  vec2 samples11 = vec2(-0.791559, -0.597705);

  vec2 newCoord;
  vec4 sum = texture2D(RT, vTexCoord);
   
  newCoord = vTexCoord + sampleDist * samples00;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples01;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples02;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples03;
  sum += texture2D(RT, newCoord);
 
  newCoord = vTexCoord + sampleDist * samples04;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples05;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples06;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples07;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples08;
  sum += texture2D(RT, newCoord);
 
  newCoord = vTexCoord + sampleDist * samples09;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples10;
  sum += texture2D(RT, newCoord);

  newCoord = vTexCoord + sampleDist * samples11;
  sum += texture2D(RT, newCoord);

  sum /= 13.0;

  gl_FragColor = vec4( sum);
}


[Helius]

 Vale, he aislado el problema.

Resulta que los offsets de textura se los paso a través de un array. Estos offsets son invariables y dependen del tamaño de la textura claro, por eso yo se los paso al principio del programa.

Pero si hago esto salen esas lineas estiradas. Sin embargo si le paso al pixel shader el array de offsets en cada frame sale perfecto ¿¿por qué??
Si dejos los offsets como estáticos (quito el comentario ese) también funciona bien. ¿¿Porqué no le valdrá con la primera vez que se los paso??

Código [Seleccionar] Expand


static const float blur_weights[13] =
{
   0.002216,
   0.008764,
   0.026995,
   0.064759,
   0.120985,
   0.176033,
   0.199471,
   0.176033,
   0.120985,
   0.064759,
   0.026995,
   0.008764,
   0.002216,
};

float2 convolution_kernel[13];

/* LOS OFFSETS SON DE ESTE ESTILO, DONDE 192 EN ESTE CASO ES EL ALTO DE LA TEXTURA
static const float2 convolution_kernel[13] =
{
   { 0, -6 / 192.0 },
   { 0, -5 / 192.0 },
   { 0, -4 / 192.0 },
   { 0, -3 / 192.0 },
   { 0, -2 / 192.0 },
   { 0, -1 / 192.0 },
   { 0,  0 / 192.0 },
   { 0,  1 / 192.0 },
   { 0,  2 / 192.0 },
   { 0,  3 / 192.0 },
   { 0,  4 / 192.0 },
   { 0,  5 / 192.0 },
   { 0,  6 / 192.0 },
};*/

//////////////////////////////////////////////////////////////////////

sampler base_map;

//////////////////////////////////////////////////////////////////////

struct PS_INPUT_STRUCT
{
float2 TexCoord0   : TEXCOORD0;
};

struct PS_OUTPUT_STRUCT
{
float4 color0:       COLOR0;
};

//////////////////////////////////////////////////////////////////////

PS_OUTPUT_STRUCT Main(PS_INPUT_STRUCT psInStruct)
{
PS_OUTPUT_STRUCT psOutStruct;

float4 Color = 0;

   for (int i = 0; i < 13; i++)
   {    
 Color += tex2D(base_map, psInStruct.TexCoord0 + convolution_kernel[i].xy) * blur_weights[i];
   }

psOutStruct.color0 = Color;

return psOutStruct;
}

[Pogacha]

 No entiendo las constantes de convolución ... haces dos pasadas ? una vertical (0, y) y luego una horizontal?
La verdad es que es un problema medio raro, pero te diria que averigues si los arrays de datos se mantienen de shader a shader o son destruidos ..., tal vez otro shader solo destruya el primer valor de l primer par ordenando mandandolo a (1, y) y de ahí las rayas horizontales ...

Saludos, siento no poder hacer mas, la verdad es que estoy olvidado del tema.

[ethernet]

 Con lo chulo que era hacer un montón de pasadas con blend :/

[Helius]

 

No entiendo las constantes de convolución ... haces dos pasadas ? una vertical (0, y) y luego una horizontal?
La verdad es que es un problema medio raro, pero te diria que averigues si los arrays de datos se mantienen de shader a shader o son destruidos ..., tal vez otro shader solo destruya el primer valor de l primer par ordenando mandandolo a (1, y) y de ahí las rayas horizontales ...

Saludos, siento no poder hacer mas, la verdad es que estoy olvidado del tema.

Sí, las constantes son (0, y) para la pasada vertical y (x, 0) para la horizontal.

Creo dos shaders completamente distintos, pero usando el mismo fichero de texto.

Asignándoles los valores al principio del programa debería funcionar pero parece que tienes razón y por algun motivo se corrompen los datos...

Bueno me conformaré pasándole el array en cada frame, por lo menos ya me sale bien  :)

Gracias y saludos.

EDIT: Dejo una fotillo con el specular bloom ya conseguido :D

[Haddd]

 que chulo  :P  

[BeRSeRKeR]

 Mola.

¿Cómo lo haces?. ¿Almacenas la componente specular en algún sitio y luego aplicas el blur y lo aplicas aditivamente a la escena o aplicas un filtro high-pass para extraer las zonas más intensas y aplicas el blur?. Con el primer método solo haces el glow del specular y con el segundo de cualquier zona intensa de la escena, ya sea specular o no.

Saludos.

[Helius]

 Sip.

Le paso un high pass sencillo, simplemente multiplicando la textura por si mismo una o dos veces (depende del contraste que necesite). Luego le paso el blur y la superpongo con aditivo a la escena original.

Es igual que el glow ya que selecciono los objetos que brillan por el canal alpha.

Saludos.

[Pogacha]

 Se ve muy bien, y si ya te andubo, como decimos aca, a otra cosa mariposa!
Saludos.