Add GLSL SMAA 1x three-pass shaders

Introduce a three-pass GLSL SMAA implementation (edge, weights, blend) and associated lookup textures/assets to replace the old ARB fragment programs and eliminate an OpenGL feedback-loop that could produce a black viewport. Adds new shader files under openq4/glprogs and .install, updates postprocess_openq4.mtr to use glslProgram + shaderTexture/shaderParm bindings, and removes the legacy .vfp blends. Registers intrinsic SMAA lookup images (_smaaArea, _smaaSearch) and includes AreaTex/SearchTex headers; Image and Material code are adjusted to expose image filter/repeat and to honor explicit texture filter/repeat from materials. Documentation and packaging checks were updated to reflect the new assets, and a small engine-side singleplayer flashlight workaround (cvar + input remap) was added in Session.cpp.

Author: themuffinator

.install/openq4/glprogs/openq4_smaa_blend.fs

@@ -0,0 +1,34 @@
+uniform sampler2D ColorTex;
+uniform sampler2D BlendTex;
+uniform vec2 invTexSize;
+
+void main() {
+	vec2 texcoord = gl_TexCoord[0].st;
+
+	vec4 a;
+	a.x = texture2D( BlendTex, texcoord + vec2( invTexSize.x, 0.0 ) ).a;
+	a.y = texture2D( BlendTex, texcoord + vec2( 0.0, invTexSize.y ) ).g;
+	a.wz = texture2D( BlendTex, texcoord ).xz;
+
+	if ( dot( a, vec4( 1.0, 1.0, 1.0, 1.0 ) ) < 0.00001 ) {
+		gl_FragColor = texture2D( ColorTex, texcoord );
+		return;
+	}
+
+	bool horizontal = max( a.x, a.z ) > max( a.y, a.w );
+	vec4 blendingOffset = vec4( 0.0, a.y, 0.0, a.w );
+	vec2 blendingWeight = a.yw;
+
+	if ( horizontal ) {
+		blendingOffset = vec4( a.x, 0.0, a.z, 0.0 );
+		blendingWeight = a.xz;
+	}
+
+	blendingWeight /= max( dot( blendingWeight, vec2( 1.0, 1.0 ) ), 0.00001 );
+
+	vec4 blendingCoord = blendingOffset * vec4( invTexSize.xy, -invTexSize.xy ) + texcoord.xyxy;
+	vec4 color = blendingWeight.x * texture2D( ColorTex, blendingCoord.xy );
+	color += blendingWeight.y * texture2D( ColorTex, blendingCoord.zw );
+
+	gl_FragColor = color;
+}

.install/openq4/glprogs/openq4_smaa_blend.vs

@@ -0,0 +1,4 @@
+void main() {
+	gl_Position = ftransform();
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+}

.install/openq4/glprogs/openq4_smaa_edge.fs

@@ -0,0 +1,45 @@
+uniform sampler2D ColorTex;
+uniform vec2 invTexSize;
+
+const float kThreshold = 0.1;
+const float kLocalContrastAdaptationFactor = 2.0;
+const vec3 kLumaWeights = vec3( 0.2126, 0.7152, 0.0722 );
+
+float SampleLuma( vec2 uv ) {
+	return dot( texture2D( ColorTex, uv ).rgb, kLumaWeights );
+}
+
+void main() {
+	vec2 texcoord = gl_TexCoord[0].st;
+	vec4 offset0 = invTexSize.xyxy * vec4( -1.0, 0.0, 0.0, -1.0 ) + texcoord.xyxy;
+	vec4 offset1 = invTexSize.xyxy * vec4( 1.0, 0.0, 0.0, 1.0 ) + texcoord.xyxy;
+	vec4 offset2 = invTexSize.xyxy * vec4( -2.0, 0.0, 0.0, -2.0 ) + texcoord.xyxy;
+
+	float luma = SampleLuma( texcoord );
+	float lumaLeft = SampleLuma( offset0.xy );
+	float lumaTop = SampleLuma( offset0.zw );
+
+	vec4 delta;
+	delta.xy = abs( luma - vec2( lumaLeft, lumaTop ) );
+
+	vec2 edges = step( vec2( kThreshold, kThreshold ), delta.xy );
+	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 ) {
+		discard;
+	}
+
+	float lumaRight = SampleLuma( offset1.xy );
+	float lumaBottom = SampleLuma( offset1.zw );
+	delta.zw = abs( luma - vec2( lumaRight, lumaBottom ) );
+
+	vec2 maxDelta = max( delta.xy, delta.zw );
+
+	float lumaLeftLeft = SampleLuma( offset2.xy );
+	float lumaTopTop = SampleLuma( offset2.zw );
+	delta.zw = abs( vec2( lumaLeft, lumaTop ) - vec2( lumaLeftLeft, lumaTopTop ) );
+
+	maxDelta = max( maxDelta, delta.zw );
+	float finalDelta = max( maxDelta.x, maxDelta.y );
+
+	edges *= step( vec2( finalDelta, finalDelta ), vec2( kLocalContrastAdaptationFactor, kLocalContrastAdaptationFactor ) * delta.xy );
+	gl_FragColor = vec4( edges, 0.0, 0.0 );
+}

.install/openq4/glprogs/openq4_smaa_edge.vs

@@ -0,0 +1,4 @@
+void main() {
+	gl_Position = ftransform();
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+}

.install/openq4/glprogs/openq4_smaa_weights.fs

@@ -0,0 +1,124 @@
+uniform sampler2D EdgesTex;
+uniform sampler2D AreaTex;
+uniform sampler2D SearchTex;
+uniform vec2 invTexSize;
+
+const float kMaxSearchSteps = 8.0;
+const float kAreaMaxDistance = 16.0;
+const vec2 kAreaTexPixelSize = vec2( 1.0 / 160.0, 1.0 / 560.0 );
+const float kAreaTexSubtexSize = 1.0 / 7.0;
+const vec2 kSearchTexSize = vec2( 66.0, 33.0 );
+const vec2 kSearchTexPackedSize = vec2( 64.0, 16.0 );
+
+vec2 RoundVec2( vec2 value ) {
+	return floor( value + vec2( 0.5, 0.5 ) );
+}
+
+float SampleSearchLength( vec2 e, float offsetValue ) {
+	vec2 scale = kSearchTexSize * vec2( 0.5, -1.0 );
+	vec2 bias = kSearchTexSize * vec2( offsetValue, 1.0 );
+
+	scale += vec2( -1.0, 1.0 );
+	bias += vec2( 0.5, -0.5 );
+
+	scale /= kSearchTexPackedSize;
+	bias /= kSearchTexPackedSize;
+
+	return texture2D( SearchTex, scale * e + bias ).r;
+}
+
+float SearchXLeft( vec2 texcoord, float endValue ) {
+	vec2 e = vec2( 0.0, 1.0 );
+	while ( texcoord.x > endValue && e.g > 0.8281 && e.r == 0.0 ) {
+		e = texture2D( EdgesTex, texcoord ).rg;
+		texcoord -= vec2( 2.0 * invTexSize.x, 0.0 );
+	}
+
+	float offsetValue = -( 255.0 / 127.0 ) * SampleSearchLength( e, 0.0 ) + 3.25;
+	return invTexSize.x * offsetValue + texcoord.x;
+}
+
+float SearchXRight( vec2 texcoord, float endValue ) {
+	vec2 e = vec2( 0.0, 1.0 );
+	while ( texcoord.x < endValue && e.g > 0.8281 && e.r == 0.0 ) {
+		e = texture2D( EdgesTex, texcoord ).rg;
+		texcoord += vec2( 2.0 * invTexSize.x, 0.0 );
+	}
+
+	float offsetValue = -( 255.0 / 127.0 ) * SampleSearchLength( e, 0.5 ) + 3.25;
+	return -invTexSize.x * offsetValue + texcoord.x;
+}
+
+float SearchYUp( vec2 texcoord, float endValue ) {
+	vec2 e = vec2( 1.0, 0.0 );
+	while ( texcoord.y > endValue && e.r > 0.8281 && e.g == 0.0 ) {
+		e = texture2D( EdgesTex, texcoord ).rg;
+		texcoord -= vec2( 0.0, 2.0 * invTexSize.y );
+	}
+
+	float offsetValue = -( 255.0 / 127.0 ) * SampleSearchLength( e.gr, 0.0 ) + 3.25;
+	return invTexSize.y * offsetValue + texcoord.y;
+}
+
+float SearchYDown( vec2 texcoord, float endValue ) {
+	vec2 e = vec2( 1.0, 0.0 );
+	while ( texcoord.y < endValue && e.r > 0.8281 && e.g == 0.0 ) {
+		e = texture2D( EdgesTex, texcoord ).rg;
+		texcoord += vec2( 0.0, 2.0 * invTexSize.y );
+	}
+
+	float offsetValue = -( 255.0 / 127.0 ) * SampleSearchLength( e.gr, 0.5 ) + 3.25;
+	return -invTexSize.y * offsetValue + texcoord.y;
+}
+
+vec2 SampleArea( vec2 dist, float e1, float e2, float offsetValue ) {
+	vec2 texcoord = vec2( kAreaMaxDistance, kAreaMaxDistance ) * RoundVec2( 4.0 * vec2( e1, e2 ) ) + dist;
+	texcoord = kAreaTexPixelSize * texcoord + 0.5 * kAreaTexPixelSize;
+	texcoord.y = kAreaTexSubtexSize * offsetValue + texcoord.y;
+	return texture2D( AreaTex, texcoord ).rg;
+}
+
+void main() {
+	vec2 texcoord = gl_TexCoord[0].st;
+	vec2 rtSize = 1.0 / max( invTexSize, vec2( 0.000001, 0.000001 ) );
+	vec2 pixcoord = texcoord * rtSize;
+
+	vec4 offset0 = invTexSize.xyxy * vec4( -0.25, -0.125, 1.25, -0.125 ) + texcoord.xyxy;
+	vec4 offset1 = invTexSize.xyxy * vec4( -0.125, -0.25, -0.125, 1.25 ) + texcoord.xyxy;
+	vec4 offset2 = vec4( invTexSize.x, invTexSize.x, invTexSize.y, invTexSize.y ) *
+		( vec4( -2.0, 2.0, -2.0, 2.0 ) * kMaxSearchSteps ) +
+		vec4( offset0.x, offset0.z, offset1.y, offset1.w );
+
+	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );
+	vec2 e = texture2D( EdgesTex, texcoord ).rg;
+
+	if ( e.g > 0.0 ) {
+		vec3 coords;
+		coords.x = SearchXLeft( offset0.xy, offset2.x );
+		coords.y = offset1.y;
+		float leftEdge = texture2D( EdgesTex, coords.xy ).r;
+
+		coords.z = SearchXRight( offset0.zw, offset2.y );
+		vec2 d = abs( RoundVec2( rtSize.xx * vec2( coords.x, coords.z ) - pixcoord.xx ) );
+		vec2 sqrtD = sqrt( d );
+		float rightEdge = texture2D( EdgesTex, coords.zy + vec2( invTexSize.x, 0.0 ) ).r;
+
+		weights.rg = SampleArea( sqrtD, leftEdge, rightEdge, 0.0 );
+	}
+
+	if ( e.r > 0.0 ) {
+		vec3 coords;
+		coords.y = SearchYUp( offset1.xy, offset2.z );
+		coords.x = offset0.x;
+		float topEdge = texture2D( EdgesTex, coords.xy ).g;
+
+		coords.z = SearchYDown( offset1.zw, offset2.w );
+		vec2 d = abs( RoundVec2( rtSize.yy * vec2( coords.y, coords.z ) - pixcoord.yy ) );
+		vec2 sqrtD = sqrt( d );
+		float bottomEdge = texture2D( EdgesTex, coords.xz + vec2( 0.0, invTexSize.y ) ).g;
+
+		weights.ba = SampleArea( sqrtD, topEdge, bottomEdge, 0.0 );
+	}
+
+	gl_FragColor = weights;
+}

.install/openq4/glprogs/openq4_smaa_weights.vs

@@ -0,0 +1,4 @@
+void main() {
+	gl_Position = ftransform();
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+}

.install/openq4/materials/postprocess_openq4.mtr

@@ -47,8 +47,23 @@ postprocess/openq4_smaa_edge
 	noShadows
 	{
 		blend gl_one, gl_zero
-		program openq4_smaa_edge.vfp
-		fragmentMap 0 clamp _postProcessAlbedo0
+		glslProgram openq4_smaa_edge.fs
+		shaderParm invTexSize 1.0 / VideoWidth, 1.0 / VideoHeight
+		shaderTexture ColorTex nearest clamp _forwardRenderResolvedAlbedo
+	}
+}
+
+postprocess/openq4_smaa_weights
+{
+	sort postProcess
+	noShadows
+	{
+		blend gl_one, gl_zero
+		glslProgram openq4_smaa_weights.fs
+		shaderParm invTexSize 1.0 / VideoWidth, 1.0 / VideoHeight
+		shaderTexture EdgesTex linear clamp _postProcessAlbedo1
+		shaderTexture AreaTex linear clamp _smaaArea
+		shaderTexture SearchTex linear clamp _smaaSearch
 	}
 }
 
@@ -58,9 +73,10 @@ postprocess/openq4_smaa_blend
 	noShadows
 	{
 		blend gl_one, gl_zero
-		program openq4_smaa_blend.vfp
-		fragmentMap 0 clamp _currentRender
-		fragmentMap 1 clamp _postProcessAlbedo1
+		glslProgram openq4_smaa_blend.fs
+		shaderParm invTexSize 1.0 / VideoWidth, 1.0 / VideoHeight
+		shaderTexture ColorTex linear clamp _forwardRenderResolvedAlbedo
+		shaderTexture BlendTex linear clamp _postProcessAlbedo0
 	}
 }
 

README.md

@@ -73,7 +73,7 @@ To play OpenQ4, you need:
 - **CRT Emulation**: Optional CRT post-process with scanlines, mask, curvature, and chromatic offset controls
 - **Shadow Mapping Pipeline**: Experimental shadow-map support for projected and point lights, with cascaded shadow maps (CSM) actively under development
 - **Resolution Scaling and Supersample Controls**: Screen-fraction rendering supports lower-resolution upscale modes and menu-exposed supersample-style presets for image-quality tuning
-- **Modern AA and Upscaling**: MSAA, SMAA, and high-quality resolution-scaling paths for cleaner output across a wide range of hardware
+- **Modern AA and Upscaling**: MSAA, official SMAA 1x (medium preset), and high-quality resolution-scaling paths for cleaner output across a wide range of hardware
 
 ### Display and UX Improvements
 - **Automatic Aspect-Ratio Management**: UI, FOV, zoom behavior, and view-weapon framing adapt from live render size instead of legacy manual aspect toggles
@@ -555,6 +555,7 @@ OpenQ4 builds upon the work of many talented developers and projects:
 - **GLEW Team** - Nigel Stewart, Milan Ikits, Marcelo E. Magallon, Lev Povalahev
 - **OpenAL Soft Contributors** - 3D audio implementation
 - **SDL Team** - Cross-platform framework
+- **Jorge Jimenez, Jose I. Echevarria, Belen Masia, Fernando Navarro, Diego Gutierrez** - [SMAA](https://www.iryoku.com/smaa/) reference implementation and lookup textures
 
 ### Special Thanks
 - The Quake and id Tech community for continued support and enthusiasm

docs-dev/renderdoc-workflow.md

@@ -4,11 +4,12 @@ This document covers the OpenQ4 RenderDoc status and the March 2026 black-viewpo
 
 ## Root Cause
 
-- The black viewport reports were not caused by missing SMAA assets in the current release package.
-- The actual failure was an undefined OpenGL feedback loop in the SMAA neighborhood-blend pass:
-  - `OpenQ4-GameLibs/src/game/Game_render.cpp` already copies the resolved scene into `_currentRender` before the SMAA passes.
+- The black viewport reports were not caused by missing SMAA assets in the release package.
+- The older two-pass SMAA placeholder path had an undefined OpenGL feedback loop in the neighborhood-blend pass:
+  - `OpenQ4-GameLibs/src/game/Game_render.cpp` already copied the resolved scene into `_currentRender` before the SMAA passes.
   - [`openq4/materials/postprocess_openq4.mtr`](../openq4/materials/postprocess_openq4.mtr) previously drew `postprocess/openq4_smaa_blend` into `_postProcessAlbedo0` while also sampling `_postProcessAlbedo0`.
 - Some drivers preserved the previous texture contents and appeared to work. Others returned black or undefined data. That is why the issue only reproduced for some users and clustered around `r_postAA 1`.
+- Current builds no longer use that path. `r_postAA 1` now runs a three-pass GLSL SMAA 1x implementation: edge detection, blending-weight calculation, and neighborhood blending.
 
 ## Current RenderDoc Limitation
 
@@ -49,23 +50,40 @@ On the current renderer, the launch is still expected to fail before first frame
 
 ## What To Inspect
 
-When reviewing an older or future capture in RenderDoc, find the draw using `postprocess/openq4_smaa_blend`.
+When reviewing an older or future capture in RenderDoc, inspect the three SMAA passes in order:
 
-Expected bindings on a fixed build:
+- `postprocess/openq4_smaa_edge`
+- `postprocess/openq4_smaa_weights`
+- `postprocess/openq4_smaa_blend`
 
-- Render target: `_postProcessAlbedo0`
-- Texture slot 0: `_currentRender`
-- Texture slot 1: `_postProcessAlbedo1`
+Expected bindings on a fixed build:
 
-If texture slot 0 matches the render target, the build still contains the broken feedback loop.
+- `postprocess/openq4_smaa_edge`
+  - Render target: `_postProcessAlbedo1`
+  - Texture slot 0: `_currentRender`
+- `postprocess/openq4_smaa_weights`
+  - Render target: `_postProcessAlbedo0`
+  - Texture slot 0: `_postProcessAlbedo1`
+  - Texture slot 1: `_smaaArea`
+  - Texture slot 2: `_smaaSearch`
+- `postprocess/openq4_smaa_blend`
+  - Render target: `_postProcessAlbedo1`
+  - Texture slot 0: `_currentRender`
+  - Texture slot 1: `_postProcessAlbedo0`
+
+If the blend pass ever samples the same texture it is rendering to, the build still contains a broken feedback loop.
 
 ## Release Package Audit
 
 `tools/build/package_nightly.py` now fails packaging if `pak0.pk4` is missing any of these required runtime files:
 
 - `materials/postprocess_openq4.mtr`
-- `glprogs/openq4_smaa_edge.vfp`
-- `glprogs/openq4_smaa_blend.vfp`
+- `glprogs/openq4_smaa_edge.vs`
+- `glprogs/openq4_smaa_edge.fs`
+- `glprogs/openq4_smaa_weights.vs`
+- `glprogs/openq4_smaa_weights.fs`
+- `glprogs/openq4_smaa_blend.vs`
+- `glprogs/openq4_smaa_blend.fs`
 
 This check is meant to catch packaging regressions in the postprocess stack before release artifacts ship.
 

docs-user/display-settings.md

@@ -31,7 +31,7 @@ This guide covers OpenQ4 display/window settings for end users, including multi-
 | Setting | Default | What it does |
 |---|---:|---|
 | `r_multiSamples` | `0` | MSAA sample count for the main scene render target (`0`, `2`, `4`, `8`, `16`; `0` = off). |
-| `r_postAA` | `0` | Post AA mode (`0` = off, `1` = SMAA 1x). |
+| `r_postAA` | `0` | Post AA mode (`0` = off, `1` = official SMAA 1x using the medium preset). |
 | `r_msaaAlphaToCoverage` | `1` | Enables alpha-to-coverage for perforated/alpha-tested materials when MSAA is active. Helps foliage/fences look cleaner. |
 | `r_msaaResolveDepth` | `0` | Also resolves depth during MSAA resolve. Usually leave this off unless debugging a depth-dependent edge case. |
 
@@ -191,4 +191,4 @@ vid_restart
 - If UI appears too centered/boxed on wide displays, set `ui_aspectCorrection 0`.
 - If the window opens off-screen after a monitor change, set `r_screen` explicitly to the target monitor and restart video; OpenQ4 will also attempt to recover automatically.
 - If AA settings seem unchanged, check values with `r_multiSamples`, `r_postAA`, and `r_msaaAlphaToCoverage`, then run `vid_restart`.
-- If enabling `r_postAA 1` turns the 3D viewport black on an older build, set `r_postAA 0`, run `vid_restart`, and attach `openq4.log` plus the output of `gfxInfo`. RenderDoc capture is not yet supported on the current OpenQ4 renderer.
+- If enabling `r_postAA 1` turns the 3D viewport black on an older build, set `r_postAA 0`, run `vid_restart`, and attach `openq4.log` plus the output of `gfxInfo`. Current builds use a three-pass GLSL SMAA path and should no longer hit the old feedback-loop failure. RenderDoc capture is not yet supported on the current OpenQ4 renderer.