Merge pull request #21 from rz5/master

(crt-lottes-multipass) Style nits

crt/shaders/crt-lottes-multipass/crt-lottes-multipass.slang

@@ -73,62 +73,91 @@ vec3 ToSrgb(vec3 c)
 }
   
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.SourceSize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.SourceSize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
   
 // Return scanline weight.
-float Scan(vec2 pos,float off){
+float Scan(vec2 pos, float off)
+{
     float dst = Dist(pos).y;
-  return Gaus(dst+off,hardScan);}
+
+    return Gaus(dst + off, hardScan);
+}
   
 // Return scanline weight for bloom.
-float BloomScan(vec2 pos,float off){
+float BloomScan(vec2 pos, float off)
+{
     float dst = Dist(pos).y;
-  return Gaus(dst+off,hardBloomScan);}
+    
+    return Gaus(dst + off, hardBloomScan);
+}
   
 // Allow nearest three lines to effect pixel.
-vec3 Tri(vec2 pos){
+vec3 Tri(vec2 pos)
+{
     vec3 a = texture(horz3minus1, pos).rgb;//Horz3(pos,-1.0);
     vec3 b = texture(horz5,       pos).rgb;//Horz5(pos, 0.0);
     vec3 c = texture(horz3plus1,  pos).rgb;//Horz3(pos, 1.0);
+
     float wa = Scan(pos, -1.0);
     float wb = Scan(pos,  0.0);
     float wc = Scan(pos,  1.0);
-  return a*wa+b*wb+c*wc;}
+ 
+    return a*wa+b*wb+c*wc;
+}
   
 // Small bloom.
-vec3 Bloom(vec2 pos){
+vec3 Bloom(vec2 pos)
+{
     vec3 a = texture(horz5minus2, pos).rgb;//Horz5(pos,-2.0);
     vec3 b = texture(horz7minus1, pos).rgb;//Horz7(pos,-1.0);
     vec3 c = texture(horz7,       pos).rgb;//Horz7(pos, 0.0);
     vec3 d = texture(horz7plus1,  pos).rgb;//Horz7(pos, 1.0);
     vec3 e = texture(horz5plus2,  pos).rgb;//Horz5(pos, 2.0);
+    
     float wa = BloomScan(pos, -2.0);
     float wb = BloomScan(pos, -1.0);
     float wc = BloomScan(pos,  0.0);
     float wd = BloomScan(pos,  1.0);
     float we = BloomScan(pos,  2.0);
-  return a*wa+b*wb+c*wc+d*wd+e*we;}
+    
+    return a*wa+b*wb+c*wc+d*wd+e*we;
+}
   
 // Distortion of scanlines, and end of screen alpha.
-vec2 Warp(vec2 pos){
+vec2 Warp(vec2 pos)
+{
     pos  = pos*2.0-1.0;    
     pos *= vec2(1.0 + (pos.y*pos.y)*warpX, 1.0 + (pos.x*pos.x)*warpY);
-  return pos*0.5+0.5;}
+    
+    return pos*0.5 + 0.5;
+}
   
 // Shadow mask.
-vec3 Mask(vec2 pos){
+vec3 Mask(vec2 pos)
+{
     vec3 mask = vec3(maskDark, maskDark, maskDark);
   
     // Very compressed TV style shadow mask.
-  if (shadowMask == 1.0) {
+    if (shadowMask == 1.0) 
+    {
         float line = maskLight;
         float odd = 0.0;
-    if(fract(pos.x/6.0)<0.5)odd=1.0;
-    if(fract((pos.y+odd)/2.0)<0.5)line=maskDark;  
-    pos.x=fract(pos.x/3.0);
+        
+        if (fract(pos.x*0.166666666) < 0.5) odd = 1.0;
+        if (fract((pos.y + odd) * 0.5) < 0.5) line = maskDark;  
+        
+        pos.x = fract(pos.x*0.333333333);
 
         if      (pos.x < 0.333) mask.r = maskLight;
         else if (pos.x < 0.666) mask.g = maskLight;
@@ -137,8 +166,9 @@ vec3 Mask(vec2 pos){
     } 
 
     // Aperture-grille.
-  else if (shadowMask == 2.0) {
-    pos.x=fract(pos.x/3.0);
+    else if (shadowMask == 2.0) 
+    {
+        pos.x = fract(pos.x*0.333333333);
 
         if      (pos.x < 0.333) mask.r = maskLight;
         else if (pos.x < 0.666) mask.g = maskLight;
@@ -146,9 +176,10 @@ vec3 Mask(vec2 pos){
     } 
 
     // Stretched VGA style shadow mask (same as prior shaders).
-  else if (shadowMask == 3.0) {
+    else if (shadowMask == 3.0) 
+    {
         pos.x += pos.y*3.0;
-    pos.x=fract(pos.x/6.0);
+        pos.x  = fract(pos.x*0.166666666);
 
         if      (pos.x < 0.333) mask.r = maskLight;
         else if (pos.x < 0.666) mask.g = maskLight;
@@ -156,29 +187,34 @@ vec3 Mask(vec2 pos){
     }
 
     // VGA style shadow mask.
-  else if (shadowMask == 4.0) {
+    else if (shadowMask == 4.0) 
+    {
         pos.xy  = floor(pos.xy*vec2(1.0, 0.5));
         pos.x  += pos.y*3.0;
-    pos.x=fract(pos.x/6.0);
+        pos.x   = fract(pos.x*0.166666666);
 
         if      (pos.x < 0.333) mask.r = maskLight;
         else if (pos.x < 0.666) mask.g = maskLight;
         else                    mask.b = maskLight;
     }
 
-  return mask;}
+    return mask;
+}
 
 void main()
 {
     vec2 pos = Warp(vTexCoord);
     vec3 outColor = Tri(pos);
+
 #ifdef DO_BLOOM
     //Add Bloom
     outColor.rgb += Bloom(pos)*bloomAmount;
 #endif
+
     if (shadowMask > 0.0)
         outColor.rgb *= Mask(vTexCoord.xy / global.OutputSize.zw * 1.000001);
-//hacky clamp fix
+    
+    /* TODO/FIXME - hacky clamp fix */
     vec2 bordertest = (pos);
     if ( bordertest.x > 0.0001 && bordertest.x < 0.9999 && bordertest.y > 0.0001 && bordertest.y < 0.9999)
         outColor.rgb = outColor.rgb;

crt/shaders/crt-lottes-multipass/horz3minus1.slang

@@ -32,30 +32,44 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 3-tap Gaussian filter along horz line.
-vec3 Horz3(vec2 pos,float off){
+vec3 Horz3(vec2 pos, float off)
+{
     vec3 b = Fetch(pos,vec2(-1.0, off));
     vec3 c = Fetch(pos,vec2( 0.0, off));
     vec3 d = Fetch(pos,vec2( 1.0, off));
     float dst = Dist(pos).x;
+    
     // Convert distance to weight.
     float scale = hardPix;
     float wb = Gaus(dst - 1.0, scale);
     float wc = Gaus(dst + 0.0, scale);
     float wd = Gaus(dst + 1.0, scale);
+    
     // Return filtered sample.
-  return (b*wb+c*wc+d*wd)/(wb+wc+wd);}
+    return (b*wb+c*wc+d*wd) / (wb+wc+wd);
+}
 
 void main()
 {

crt/shaders/crt-lottes-multipass/horz3plus1.slang

@@ -32,30 +32,44 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 3-tap Gaussian filter along horz line.
-vec3 Horz3(vec2 pos,float off){
+vec3 Horz3(vec2 pos, float off)
+{
     vec3 b = Fetch(pos,vec2(-1.0, off));
     vec3 c = Fetch(pos,vec2( 0.0, off));
     vec3 d = Fetch(pos,vec2( 1.0, off));
     float dst = Dist(pos).x;
+    
     // Convert distance to weight.
     float scale = hardPix;
     float wb = Gaus(dst - 1.0, scale);
     float wc = Gaus(dst + 0.0, scale);
     float wd = Gaus(dst + 1.0, scale);
+    
     // Return filtered sample.
-  return (b*wb+c*wc+d*wd)/(wb+wc+wd);}
+    return (b*wb+c*wc+d*wd) / (wb+wc+wd);
+}
 
 void main()
 {

crt/shaders/crt-lottes-multipass/horz5.slang

@@ -32,25 +32,37 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 5-tap Gaussian filter along horz line.
-vec3 Horz5(vec2 pos,float off){
+vec3 Horz5(vec2 pos,float off)
+{
     vec3 a = Fetch(pos,vec2(-2.0, off));
     vec3 b = Fetch(pos,vec2(-1.0, off));
     vec3 c = Fetch(pos,vec2( 0.0, off));
     vec3 d = Fetch(pos,vec2( 1.0, off));
     vec3 e = Fetch(pos,vec2( 2.0, off));
     float dst = Dist(pos).x;
+    
     // Convert distance to weight.
     float scale = hardPix;
     float wa = Gaus(dst - 2.0, scale);
@@ -58,8 +70,10 @@ vec3 Horz5(vec2 pos,float off){
     float wc = Gaus(dst + 0.0, scale);
     float wd = Gaus(dst + 1.0, scale);
     float we = Gaus(dst + 2.0, scale);
+    
      // Return filtered sample.
-  return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);}
+    return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);
+}
 
 void main()
 {

crt/shaders/crt-lottes-multipass/horz5minus2.slang

@@ -32,25 +32,37 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 5-tap Gaussian filter along horz line.
-vec3 Horz5(vec2 pos,float off){
+vec3 Horz5(vec2 pos,float off)
+{
     vec3 a = Fetch(pos,vec2(-2.0, off));
     vec3 b = Fetch(pos,vec2(-1.0, off));
     vec3 c = Fetch(pos,vec2( 0.0, off));
     vec3 d = Fetch(pos,vec2( 1.0, off));
     vec3 e = Fetch(pos,vec2( 2.0, off));
     float dst = Dist(pos).x;
+    
     // Convert distance to weight.
     float scale = hardPix;
     float wa = Gaus(dst - 2.0, scale);
@@ -58,8 +70,10 @@ vec3 Horz5(vec2 pos,float off){
     float wc = Gaus(dst + 0.0, scale);
     float wd = Gaus(dst + 1.0, scale);
     float we = Gaus(dst + 2.0, scale);
+    
      // Return filtered sample.
-  return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);}
+    return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);
+}
 
 void main()
 {

crt/shaders/crt-lottes-multipass/horz5plus2.slang

@@ -32,25 +32,37 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 5-tap Gaussian filter along horz line.
-vec3 Horz5(vec2 pos,float off){
+vec3 Horz5(vec2 pos,float off)
+{
     vec3 a = Fetch(pos,vec2(-2.0, off));
     vec3 b = Fetch(pos,vec2(-1.0, off));
     vec3 c = Fetch(pos,vec2( 0.0, off));
     vec3 d = Fetch(pos,vec2( 1.0, off));
     vec3 e = Fetch(pos,vec2( 2.0, off));
     float dst = Dist(pos).x;
+    
     // Convert distance to weight.
     float scale = hardPix;
     float wa = Gaus(dst - 2.0, scale);
@@ -58,8 +70,10 @@ vec3 Horz5(vec2 pos,float off){
     float wc = Gaus(dst + 0.0, scale);
     float wd = Gaus(dst + 1.0, scale);
     float we = Gaus(dst + 2.0, scale);
+    
      // Return filtered sample.
-  return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);}
+    return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);
+}
 
 void main()
 {

crt/shaders/crt-lottes-multipass/horz7.slang

@@ -32,19 +32,30 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 7-tap Gaussian filter along horz line.
-vec3 Horz7(vec2 pos,float off){
+vec3 Horz7(vec2 pos, float off)
+{
     vec3 a = Fetch(pos, vec2(-3.0, off));
     vec3 b = Fetch(pos, vec2(-2.0, off));
     vec3 c = Fetch(pos, vec2(-1.0, off));
@@ -53,6 +64,7 @@ vec3 Horz7(vec2 pos,float off){
     vec3 f = Fetch(pos, vec2( 2.0, off));
     vec3 g = Fetch(pos, vec2( 3.0, off));
     float dst = Dist(pos).x;
+
     // Convert distance to weight.
     float scale = hardBloomPix;
     float wa = Gaus(dst - 3.0, scale);
@@ -62,8 +74,10 @@ vec3 Horz7(vec2 pos,float off){
     float we = Gaus(dst + 1.0, scale);
     float wf = Gaus(dst + 2.0, scale);
     float wg = Gaus(dst + 3.0, scale);
+
     // Return filtered sample.
-  return (a*wa+b*wb+c*wc+d*wd+e*we+f*wf+g*wg)/(wa+wb+wc+wd+we+wf+wg);}
+    return (a*wa+b*wb+c*wc+d*wd+e*we+f*wf+g*wg)/(wa+wb+wc+wd+we+wf+wg);
+}
 
 void main()
 {

crt/shaders/crt-lottes-multipass/horz7minus1.slang

@@ -32,19 +32,30 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 7-tap Gaussian filter along horz line.
-vec3 Horz7(vec2 pos,float off){
+vec3 Horz7(vec2 pos, float off)
+{
     vec3 a = Fetch(pos, vec2(-3.0, off));
     vec3 b = Fetch(pos, vec2(-2.0, off));
     vec3 c = Fetch(pos, vec2(-1.0, off));
@@ -53,6 +64,7 @@ vec3 Horz7(vec2 pos,float off){
     vec3 f = Fetch(pos, vec2( 2.0, off));
     vec3 g = Fetch(pos, vec2( 3.0, off));
     float dst = Dist(pos).x;
+
     // Convert distance to weight.
     float scale = hardBloomPix;
     float wa = Gaus(dst - 3.0, scale);
@@ -62,8 +74,10 @@ vec3 Horz7(vec2 pos,float off){
     float we = Gaus(dst + 1.0, scale);
     float wf = Gaus(dst + 2.0, scale);
     float wg = Gaus(dst + 3.0, scale);
+
     // Return filtered sample.
-  return (a*wa+b*wb+c*wc+d*wd+e*we+f*wf+g*wg)/(wa+wb+wc+wd+we+wf+wg);}
+    return (a*wa+b*wb+c*wc+d*wd+e*we+f*wf+g*wg)/(wa+wb+wc+wd+we+wf+wg);
+}
 
 void main()
 {

crt/shaders/crt-lottes-multipass/horz7plus1.slang

@@ -32,19 +32,30 @@ layout(set = 0, binding = 2) uniform sampler2D REFERENCE;
 
 // Nearest emulated sample given floating point position and texel offset.
 // Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
+vec3 Fetch(vec2 pos, vec2 off) 
+{
     pos = vTexCoord;//(floor(pos*global.REFERENCESize.xy+off)+vec2(0.5,0.5)) * global.REFERENCESize.zw;
+    
     return brightboost * texture(REFERENCE, pos.xy).rgb;
 }
 
 // Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*global.REFERENCESize.xy;return -((pos-floor(pos))-vec2(0.5));}
+vec2 Dist(vec2 pos)
+{
+    pos = pos*global.REFERENCESize.xy;
+    
+    return -((pos - floor(pos)) - vec2(0.5));
+}
     
 // 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pow(abs(pos),shape));}
+float Gaus(float pos, float scale)
+{
+    return exp2(scale*pow(abs(pos), shape));
+}
 
 // 7-tap Gaussian filter along horz line.
-vec3 Horz7(vec2 pos,float off){
+vec3 Horz7(vec2 pos, float off)
+{
     vec3 a = Fetch(pos, vec2(-3.0, off));
     vec3 b = Fetch(pos, vec2(-2.0, off));
     vec3 c = Fetch(pos, vec2(-1.0, off));
@@ -53,6 +64,7 @@ vec3 Horz7(vec2 pos,float off){
     vec3 f = Fetch(pos, vec2( 2.0, off));
     vec3 g = Fetch(pos, vec2( 3.0, off));
     float dst = Dist(pos).x;
+
     // Convert distance to weight.
     float scale = hardBloomPix;
     float wa = Gaus(dst - 3.0, scale);
@@ -62,8 +74,10 @@ vec3 Horz7(vec2 pos,float off){
     float we = Gaus(dst + 1.0, scale);
     float wf = Gaus(dst + 2.0, scale);
     float wg = Gaus(dst + 3.0, scale);
+
     // Return filtered sample.
-  return (a*wa+b*wb+c*wc+d*wd+e*we+f*wf+g*wg)/(wa+wb+wc+wd+we+wf+wg);}
+    return (a*wa+b*wb+c*wc+d*wd+e*we+f*wf+g*wg)/(wa+wb+wc+wd+we+wf+wg);
+}
 
 void main()
 {