Update to v091 release.

byuu says:

A few issues crept up in the last release, this should take care of
them.

First, it seems that the 32-bit runtime on 64-bit versions of Windows
have 64-bit time functions; whereas true 32-bit Windows does not. This
was causing a DLL error when attempting to load bsnes v090.

Second, when there were more than 2,000 files in the same folder on
Windows, it was lagging the file browser. With OV2's help, I've fixed
that and it'll now load the list instantly.

Lastly, I've included the missing video shaders this time.

shaders/Archive/HDR-TV.OpenGL.shader

@@ -0,0 +1,17 @@
+shader language=GLSL
+	vertex~
+		void main(void) {
+			gl_Position = ftransform();
+			gl_TexCoord[0] = gl_MultiTexCoord0;
+		}
+
+	fragment~ filter=linear
+		uniform sampler2D rubyTexture;
+		
+		void main(void) {   
+			vec4 rgb = texture2D(rubyTexture, gl_TexCoord[0].xy);
+			vec4 intens = smoothstep(0.2,0.8,rgb) + normalize(vec4(rgb.xyz, 1.0));
+			
+			if(fract(gl_FragCoord.y * 0.5) > 0.5) intens = rgb * 0.8;
+			gl_FragColor = intens;
+		}

shaders/Archive/Watercolor.OpenGL.shader

@@ -0,0 +1,61 @@
+shader language=GLSL
+	vertex~
+		uniform vec2 rubyTextureSize;
+		
+		void main() 
+		{
+			float x = 0.5 * (1.0 / rubyTextureSize.x);
+			float y = 0.5 * (1.0 / rubyTextureSize.y);
+			vec2 dg1 = vec2( x, y);
+			vec2 dg2 = vec2(-x, y);
+			vec2 dx = vec2(x, 0.0);
+			vec2 dy = vec2(0.0, y);
+		
+			gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+			gl_TexCoord[0] = gl_MultiTexCoord0;
+			gl_TexCoord[1].xy = gl_TexCoord[0].xy - dg1;
+			gl_TexCoord[1].zw = gl_TexCoord[0].xy - dy;
+			gl_TexCoord[2].xy = gl_TexCoord[0].xy - dg2;
+			gl_TexCoord[2].zw = gl_TexCoord[0].xy + dx;
+			gl_TexCoord[3].xy = gl_TexCoord[0].xy + dg1;
+			gl_TexCoord[3].zw = gl_TexCoord[0].xy + dy;
+			gl_TexCoord[4].xy = gl_TexCoord[0].xy + dg2;
+			gl_TexCoord[4].zw = gl_TexCoord[0].xy - dx;
+		}
+
+	fragment~ filter=linear
+		vec4 compress(vec4 in_color, float threshold, float ratio)
+		{
+			vec4 diff = in_color - vec4(threshold);
+			diff = clamp(diff, 0.0, 100.0);
+			return in_color - (diff * (1.0 - 1.0/ratio));
+		}
+		
+		uniform sampler2D rubyTexture;
+		uniform vec2 rubyTextureSize;
+		
+		void main()
+		{
+			vec3 c00 = texture2D(rubyTexture, gl_TexCoord[1].xy).xyz;
+			vec3 c01 = texture2D(rubyTexture, gl_TexCoord[4].zw).xyz;
+			vec3 c02 = texture2D(rubyTexture, gl_TexCoord[4].xy).xyz;
+			vec3 c10 = texture2D(rubyTexture, gl_TexCoord[1].zw).xyz;
+			vec3 c11 = texture2D(rubyTexture, gl_TexCoord[0].xy).xyz;
+			vec3 c12 = texture2D(rubyTexture, gl_TexCoord[3].zw).xyz;
+			vec3 c20 = texture2D(rubyTexture, gl_TexCoord[2].xy).xyz;
+			vec3 c21 = texture2D(rubyTexture, gl_TexCoord[2].zw).xyz;
+			vec3 c22 = texture2D(rubyTexture, gl_TexCoord[3].xy).xyz;
+		
+			vec2 tex = gl_TexCoord[0].xy;
+			vec2 texsize = rubyTextureSize;
+		
+			vec3 first = mix(c00, c20, fract(tex.x * texsize.x + 0.5));
+			vec3 second = mix(c02, c22, fract(tex.x * texsize.x + 0.5));
+		
+			vec3 mid_horiz = mix(c01, c21, fract(tex.x * texsize.x + 0.5));
+			vec3 mid_vert = mix(c10, c12, fract(tex.y * texsize.y + 0.5));
+		
+			vec3 res = mix(first, second, fract(tex.y * texsize.y + 0.5));
+			vec4 final = vec4(0.26 * (res + mid_horiz + mid_vert) + 3.5 * abs(res - mix(mid_horiz, mid_vert, 0.5)), 1.0);
+			gl_FragColor = compress(final, 0.8, 5.0);
+		}

shaders/Curvature.OpenGL.shader

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <fragment filter="linear"><![CDATA[
+    uniform sampler2D rubyTexture;
+    uniform vec2 rubyInputSize;
+    uniform vec2 rubyTextureSize;
+
+    #define distortion 0.2
+
+    vec2 barrelDistortion(vec2 coord) {
+      vec2 cc = coord - 0.5;
+      float dist = dot(cc, cc);
+      return coord + cc * (dist + distortion * dist * dist) * distortion;
+    }
+
+    void main(void) {
+      vec2 coord = barrelDistortion (gl_TexCoord[0] * rubyTextureSize / rubyInputSize) * rubyInputSize / rubyTextureSize;
+
+      gl_FragColor = texture2D(rubyTexture, coord);
+    }
+  ]]></fragment>
+</shader>

shaders/HQ2x.OpenGL.shader

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <vertex><![CDATA[
+    uniform vec2 rubyTextureSize;
+
+    void main() {
+      float x = 0.5 * (1.0 / rubyTextureSize.x);
+      float y = 0.5 * (1.0 / rubyTextureSize.y);
+      vec2 dg1 = vec2( x, y);
+      vec2 dg2 = vec2(-x, y);
+      vec2 dx = vec2(x, 0.0);
+      vec2 dy = vec2(0.0, y);
+
+      gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+      gl_TexCoord[0] = gl_MultiTexCoord0;
+      gl_TexCoord[1].xy = gl_TexCoord[0].xy - dg1;
+      gl_TexCoord[1].zw = gl_TexCoord[0].xy - dy;
+      gl_TexCoord[2].xy = gl_TexCoord[0].xy - dg2;
+      gl_TexCoord[2].zw = gl_TexCoord[0].xy + dx;
+      gl_TexCoord[3].xy = gl_TexCoord[0].xy + dg1;
+      gl_TexCoord[3].zw = gl_TexCoord[0].xy + dy;
+      gl_TexCoord[4].xy = gl_TexCoord[0].xy + dg2;
+      gl_TexCoord[4].zw = gl_TexCoord[0].xy - dx;
+    }
+  ]]></vertex>
+
+  <fragment filter="nearest"><![CDATA[
+    uniform sampler2D rubyTexture;
+
+    const float mx = 0.325;      // start smoothing wt.
+    const float k = -0.250;      // wt. decrease factor
+    const float max_w = 0.25;    // max filter weigth
+    const float min_w =-0.05;    // min filter weigth
+    const float lum_add = 0.25;  // effects smoothing
+
+    void main() {
+      vec3 c00 = texture2D(rubyTexture, gl_TexCoord[1].xy).xyz; 
+      vec3 c10 = texture2D(rubyTexture, gl_TexCoord[1].zw).xyz; 
+      vec3 c20 = texture2D(rubyTexture, gl_TexCoord[2].xy).xyz; 
+      vec3 c01 = texture2D(rubyTexture, gl_TexCoord[4].zw).xyz; 
+      vec3 c11 = texture2D(rubyTexture, gl_TexCoord[0].xy).xyz; 
+      vec3 c21 = texture2D(rubyTexture, gl_TexCoord[2].zw).xyz; 
+      vec3 c02 = texture2D(rubyTexture, gl_TexCoord[4].xy).xyz; 
+      vec3 c12 = texture2D(rubyTexture, gl_TexCoord[3].zw).xyz; 
+      vec3 c22 = texture2D(rubyTexture, gl_TexCoord[3].xy).xyz; 
+      vec3 dt = vec3(1.0, 1.0, 1.0);
+
+      float md1 = dot(abs(c00 - c22), dt);
+      float md2 = dot(abs(c02 - c20), dt);
+
+      float w1 = dot(abs(c22 - c11), dt) * md2;
+      float w2 = dot(abs(c02 - c11), dt) * md1;
+      float w3 = dot(abs(c00 - c11), dt) * md2;
+      float w4 = dot(abs(c20 - c11), dt) * md1;
+
+      float t1 = w1 + w3;
+      float t2 = w2 + w4;
+      float ww = max(t1, t2) + 0.0001;
+
+      c11 = (w1 * c00 + w2 * c20 + w3 * c22 + w4 * c02 + ww * c11) / (t1 + t2 + ww);
+
+      float lc1 = k / (0.12 * dot(c10 + c12 + c11, dt) + lum_add);
+      float lc2 = k / (0.12 * dot(c01 + c21 + c11, dt) + lum_add);
+
+      w1 = clamp(lc1 * dot(abs(c11 - c10), dt) + mx, min_w, max_w);
+      w2 = clamp(lc2 * dot(abs(c11 - c21), dt) + mx, min_w, max_w);
+      w3 = clamp(lc1 * dot(abs(c11 - c12), dt) + mx, min_w, max_w);
+      w4 = clamp(lc2 * dot(abs(c11 - c01), dt) + mx, min_w, max_w);
+
+      gl_FragColor.xyz = w1 * c10 + w2 * c21 + w3 * c12 + w4 * c01 + (1.0 - w1 - w2 - w3 - w4) * c11;
+    }
+  ]]></fragment>
+</shader>

shaders/Makefile

@@ -0,0 +1,4 @@
+install:
+	mkdir -p ~/.config/bsnes/shaders
+	chmod 777 ~/.config/bsnes/shaders
+	cp *.shader ~/.config/bsnes/shaders

shaders/Pixellate.OpenGL.shader

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <vertex><![CDATA[
+    void main() {
+      gl_Position    = ftransform();
+      gl_TexCoord[0] = gl_MultiTexCoord0;
+    }
+  ]]></vertex>
+
+  <fragment filter="nearest"><![CDATA[
+    uniform sampler2D rubyTexture;
+    uniform vec2      rubyTextureSize;
+
+    void main() {
+      vec2 texelSize = 1.0 / rubyTextureSize;
+
+      vec2 range;
+      range.x = dFdx(gl_TexCoord[0].x) / 2.0 * 0.99;
+      range.y = dFdy(gl_TexCoord[0].y) / 2.0 * 0.99;
+
+      float left   = gl_TexCoord[0].x - range.x;
+      float top    = gl_TexCoord[0].y + range.y;
+      float right  = gl_TexCoord[0].x + range.x;
+      float bottom = gl_TexCoord[0].y - range.y;
+
+      vec4 topLeftColor     = texture2D(rubyTexture, (floor(vec2(left, top)     / texelSize) + 0.5) * texelSize);
+      vec4 bottomRightColor = texture2D(rubyTexture, (floor(vec2(right, bottom) / texelSize) + 0.5) * texelSize);
+      vec4 bottomLeftColor  = texture2D(rubyTexture, (floor(vec2(left, bottom)  / texelSize) + 0.5) * texelSize);
+      vec4 topRightColor    = texture2D(rubyTexture, (floor(vec2(right, top)    / texelSize) + 0.5) * texelSize);
+
+      vec2 border = clamp(round(gl_TexCoord[0] / texelSize) * texelSize, vec2(left, bottom), vec2(right, top));
+
+      float totalArea = 4.0 * range.x * range.y;
+
+      vec4 averageColor;
+      averageColor  = ((border.x - left)  * (top - border.y)    / totalArea) * topLeftColor;
+      averageColor += ((right - border.x) * (border.y - bottom) / totalArea) * bottomRightColor;
+      averageColor += ((border.x - left)  * (border.y - bottom) / totalArea) * bottomLeftColor;
+      averageColor += ((right - border.x) * (top - border.y)    / totalArea) * topRightColor;
+
+      gl_FragColor = averageColor;
+    }
+  ]]></fragment>
+</shader>

shaders/Scale2x.OpenGL.shader

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <vertex><![CDATA[
+    uniform vec2 rubyTextureSize;
+
+    void main() {
+      vec4 offsetx;
+      vec4 offsety;
+
+      gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+      offsetx.x = 1.0 / rubyTextureSize.x;
+      offsetx.y = 0.0;
+      offsetx.w = 0.0;
+      offsetx.z = 0.0;
+      offsety.y = 1.0 / rubyTextureSize.y;
+      offsety.x = 0.0;
+      offsety.w = 0.0;
+      offsety.z = 0.0;
+
+      gl_TexCoord[0] = gl_MultiTexCoord0;         //center
+      gl_TexCoord[1] = gl_TexCoord[0] - offsetx;  //left
+      gl_TexCoord[2] = gl_TexCoord[0] + offsetx;  //right
+      gl_TexCoord[3] = gl_TexCoord[0] - offsety;  //top
+      gl_TexCoord[4] = gl_TexCoord[0] + offsety;  //bottom
+    }
+  ]]></vertex>
+
+  <fragment filter="nearest"><![CDATA[
+    uniform sampler2D rubyTexture;
+    uniform vec2 rubyTextureSize;
+
+    void main() {
+      vec4 colD, colF, colB, colH, col, tmp;
+      vec2 sel;
+
+      col  = texture2DProj(rubyTexture, gl_TexCoord[0]);  //central (can be E0-E3)
+      colD = texture2DProj(rubyTexture, gl_TexCoord[1]);  //D (left)
+      colF = texture2DProj(rubyTexture, gl_TexCoord[2]);  //F (right)
+      colB = texture2DProj(rubyTexture, gl_TexCoord[3]);  //B (top)
+      colH = texture2DProj(rubyTexture, gl_TexCoord[4]);  //H (bottom)
+
+      sel = fract(gl_TexCoord[0].xy * rubyTextureSize.xy);       //where are we (E0-E3)? E0 is default
+
+      if(sel.y >= 0.5) { tmp = colB; colB = colH; colH = tmp; }  //E1 (or E3): swap B and H
+      if(sel.x >= 0.5) { tmp = colF; colF = colD; colD = tmp; }  //E2 (or E3): swap D and F 
+
+      if(colB == colD && colB != colF && colD != colH) {  //do the Scale2x rule
+        col = colD;
+      }
+
+      gl_FragColor = col;
+    }
+  ]]></fragment>
+</shader>

shaders/Sepia.Direct3D.shader

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="HLSL">
+  <source><![CDATA[
+    texture rubyTexture;
+
+    float4 vec;
+
+    sampler s0 = sampler_state { texture = <rubyTexture>; };
+    float3 LightColor = { 1.0, 0.7, 0.5 };
+    float3 DarkColor = { 0.2, 0.05, 0.0 };
+
+    float4 DiffColorPass(in float2 Tex : TEXCOORD0) : COLOR0
+    {
+      vec.x = 0.5;
+      vec.y = 1.0;
+      float3 scnColor = LightColor * tex2D(s0, Tex).xyz;
+      float3 grayXfer = float3(0.3, 0.59, 0.11);
+      float gray = dot(grayXfer, scnColor);
+      float3 muted = lerp(scnColor, gray.xxx, vec.x);
+      float3 sepia = lerp(DarkColor, LightColor, gray);
+      float3 result = lerp(muted, sepia, vec.y);
+      return float4(result, 1);
+    }
+
+    Technique T0
+    {
+      pass p0 { PixelShader = compile ps_2_0 DiffColorPass(); }
+    }
+  ]]></source>
+</shader>