Add RGB translucent shadow moments and coverage

Implement colored (RGB) translucent-shadow moments and richer coverage handling across shaders and renderer. Shaders: split translucent shadow moments into R/G/B textures, make caster shaders output three MRT moment targets, add coverage map, stage/coverage colors, vertex color modes, coverage alpha-test and per-channel absorption/tau math. Renderer: require additional GL resources for the feature (texture units >= 9, draw buffers/color attachments >= 3), add glConfig.maxDrawBuffers and maxColorAttachments and expose them in GfxInfo, initialize and check them, and gate the feature on their availability. Render targets: support multiple cubemap color attachments in idRenderTexture::MakeCurrent and use multiple moment images for projected/point translucent shadows; update program uniform bindings and program structs to handle the new arrays and coverage-related uniforms. Docs: update shadow-mapping.md to describe layered coverage, colored transmission, and hardware requirements. Overall this improves tinted/translucent shadow fidelity while disabling the path on unsupported hardware.

Author: themuffinator

.install/openq4/glprogs/openq4_shadow_interaction.fs

@@ -6,7 +6,9 @@ uniform sampler2D uLightProjectionMap;
 uniform sampler2D uDiffuseMap;
 uniform sampler2D uSpecularMap;
 uniform sampler2D uShadowMap;
-uniform sampler2D uTranslucentShadowMap;
+uniform sampler2D uTranslucentShadowMapR;
+uniform sampler2D uTranslucentShadowMapG;
+uniform sampler2D uTranslucentShadowMapB;
 
 uniform vec4 uDiffuseColor;
 uniform vec4 uSpecularColor;
@@ -89,7 +91,8 @@ float ResolveTranslucentShadowMoments( vec4 moments, float depth ) {
 	float mean = moments.y / totalTau;
 	float variance = max( moments.z / totalTau - mean * mean, kTranslucentMomentMinVariance );
 	float sigma = sqrt( variance );
-	float tau = totalTau * clamp( NormalCdf( ( depth - mean ) / sigma ), 0.0, 1.0 );
+	float fraction = clamp( NormalCdf( ( depth - mean ) / sigma ), 0.0, 1.0 );
+	float tau = totalTau * fraction;
 	return exp( -min( tau * max( uTranslucentShadowDensity, 0.0 ), 16.0 ) );
 }
 
@@ -172,21 +175,21 @@ vec4 SampleShadowCascade( vec4 shadowCoord, vec4 atlasRect, int cascadeIndex ) {
 	return vec4( shadow * ( 1.0 / 13.0 ), localUv.x, localUv.y, depth );
 }
 
-float SampleTranslucentShadowCascade( vec4 shadowCoord, vec4 atlasRect ) {
+vec3 SampleTranslucentShadowCascade( vec4 shadowCoord, vec4 atlasRect ) {
 	if ( uTranslucentShadowEnabled < 0.5 ) {
-		return 1.0;
+		return vec3( 1.0 );
 	}
 
 	vec2 localUv;
 	float depth;
 	if ( !ProjectShadowCoord( shadowCoord, localUv, depth ) ) {
-		return 1.0;
+		return vec3( 1.0 );
 	}
 	if ( localUv.x <= 0.0 || localUv.x >= 1.0 || localUv.y <= 0.0 || localUv.y >= 1.0 ) {
-		return 1.0;
+		return vec3( 1.0 );
 	}
 	if ( depth <= 0.0 || depth >= 1.0 ) {
-		return 1.0;
+		return vec3( 1.0 );
 	}
 
 	vec2 atlasMin = atlasRect.xy;
@@ -197,7 +200,10 @@ float SampleTranslucentShadowCascade( vec4 shadowCoord, vec4 atlasRect ) {
 	clampMin = min( clampMin, clampMax );
 	uv = clamp( uv, clampMin, clampMax );
 
-	return ResolveTranslucentShadowMoments( texture2D( uTranslucentShadowMap, uv ), depth );
+	return vec3(
+		ResolveTranslucentShadowMoments( texture2D( uTranslucentShadowMapR, uv ), depth ),
+		ResolveTranslucentShadowMoments( texture2D( uTranslucentShadowMapG, uv ), depth ),
+		ResolveTranslucentShadowMoments( texture2D( uTranslucentShadowMapB, uv ), depth ) );
 }
 
 float CascadeSplitDepth( int index ) {
@@ -390,7 +396,7 @@ vec4 ShadowDebugOutput( vec4 shadowInfo ) {
 	return vec4( invalidColor, 1.0 );
 }
 
-float SampleTranslucentShadowCascadeByIndex( int index ) {
+vec3 SampleTranslucentShadowCascadeByIndex( int index ) {
 	if ( index <= 0 ) {
 		return SampleTranslucentShadowCascade( vShadowCoord0, uShadowAtlasRect[0] );
 	}
@@ -403,13 +409,13 @@ float SampleTranslucentShadowCascadeByIndex( int index ) {
 	return SampleTranslucentShadowCascade( vShadowCoord3, uShadowAtlasRect[3] );
 }
 
-float SampleTranslucentShadow() {
+vec3 SampleTranslucentShadow() {
 	if ( uTranslucentShadowEnabled < 0.5 ) {
-		return 1.0;
+		return vec3( 1.0 );
 	}
 
 	int cascadeIndex = SelectCascade( vViewDepth );
-	float shadow = SampleTranslucentShadowCascadeByIndex( cascadeIndex );
+	vec3 shadow = SampleTranslucentShadowCascadeByIndex( cascadeIndex );
 	int lastInteriorIndex = uShadowCascadeCount - 2;
 
 	if ( cascadeIndex > lastInteriorIndex || uShadowCascadeBlend <= 0.0 ) {
@@ -424,7 +430,7 @@ float SampleTranslucentShadow() {
 		return shadow;
 	}
 
-	float nextShadow = SampleTranslucentShadowCascadeByIndex( cascadeIndex + 1 );
+	vec3 nextShadow = SampleTranslucentShadowCascadeByIndex( cascadeIndex + 1 );
 	float blend = clamp( ( vViewDepth - blendStart ) / blendWidth, 0.0, 1.0 );
 	return mix( shadow, nextShadow, blend );
 }

.install/openq4/glprogs/openq4_shadow_point_interaction.fs

@@ -6,7 +6,9 @@ uniform sampler2D uLightProjectionMap;
 uniform sampler2D uDiffuseMap;
 uniform sampler2D uSpecularMap;
 uniform samplerCube uPointShadowMap;
-uniform samplerCube uPointTranslucentShadowMap;
+uniform samplerCube uPointTranslucentShadowMapR;
+uniform samplerCube uPointTranslucentShadowMapG;
+uniform samplerCube uPointTranslucentShadowMapB;
 
 uniform vec4 uDiffuseColor;
 uniform vec4 uSpecularColor;
@@ -60,7 +62,8 @@ float ResolveTranslucentShadowMoments( vec4 moments, float depth ) {
 	float mean = moments.y / totalTau;
 	float variance = max( moments.z / totalTau - mean * mean, kTranslucentMomentMinVariance );
 	float sigma = sqrt( variance );
-	float tau = totalTau * clamp( NormalCdf( ( depth - mean ) / sigma ), 0.0, 1.0 );
+	float fraction = clamp( NormalCdf( ( depth - mean ) / sigma ), 0.0, 1.0 );
+	float tau = totalTau * fraction;
 	return exp( -min( tau * max( uTranslucentShadowDensity, 0.0 ), 16.0 ) );
 }
 
@@ -117,18 +120,21 @@ float SamplePointShadow() {
 	return shadow * ( 1.0 / 13.0 );
 }
 
-float SamplePointTranslucentShadow() {
+vec3 SamplePointTranslucentShadow() {
 	if ( uTranslucentShadowEnabled < 0.5 || uPointShadowFar <= 0.0 ) {
-		return 1.0;
+		return vec3( 1.0 );
 	}
 
 	float depth = length( vPointShadowVector ) / uPointShadowFar;
 	if ( depth <= 0.0 || depth >= 1.0 ) {
-		return 1.0;
+		return vec3( 1.0 );
 	}
 
 	vec3 direction = SafeNormalize( vPointShadowVector );
-	return ResolveTranslucentShadowMoments( textureCube( uPointTranslucentShadowMap, direction ), depth );
+	return vec3(
+		ResolveTranslucentShadowMoments( textureCube( uPointTranslucentShadowMapR, direction ), depth ),
+		ResolveTranslucentShadowMoments( textureCube( uPointTranslucentShadowMapG, direction ), depth ),
+		ResolveTranslucentShadowMoments( textureCube( uPointTranslucentShadowMapB, direction ), depth ) );
 }
 
 void main() {

.install/openq4/glprogs/openq4_shadow_point_translucent_caster.fs

@@ -2,40 +2,78 @@
 
 uniform float uPointShadowFar;
 uniform sampler2D uAlphaMap;
-uniform float uAlphaScale;
+uniform sampler2D uCoverageMap;
+uniform vec4 uStageColor;
+uniform vec4 uCoverageStageColor;
 uniform float uOpacitySourceMode;
+uniform float uVertexColorMode;
+uniform float uCoverageSourceMode;
+uniform float uCoverageVertexColorMode;
+uniform float uCoverageAlphaTestRef;
+uniform float uCoverageAlphaTestEnabled;
 uniform float uTranslucentMinAlpha;
 
 varying vec3 vPointShadowVector;
 varying vec2 vAlphaTexCoord;
+varying vec2 vCoverageTexCoord;
+varying vec3 vVertexColorRgb;
 varying float vVertexAlpha;
+varying float vCoverageVertexAlpha;
 
 float OpticalDepth( float alpha ) {
 	return -log( max( 1.0 - clamp( alpha, 0.0, 0.999 ), 1.0e-4 ) );
 }
 
-float StageOpacity() {
-	if ( uOpacitySourceMode > 1.5 ) {
-		return clamp( uAlphaScale * vVertexAlpha, 0.0, 0.999 );
+vec3 VertexColorRgb( float mode ) {
+	if ( mode > 1.5 ) {
+		return 1.0 - vVertexColorRgb;
+	}
+	if ( mode > 0.5 ) {
+		return vVertexColorRgb;
 	}
+	return vec3( 1.0 );
+}
 
-	vec4 sampleColor = texture2D( uAlphaMap, vAlphaTexCoord );
-	float opacity = sampleColor.a;
-	if ( uOpacitySourceMode > 0.5 ) {
-		opacity = max( opacity, dot( sampleColor.rgb, vec3( 0.2126, 0.7152, 0.0722 ) ) );
+float CoverageAmount() {
+	if ( uCoverageSourceMode < 0.5 ) {
+		return 1.0;
 	}
 
-	return clamp( opacity * uAlphaScale * vVertexAlpha, 0.0, 0.999 );
+	vec4 coverageSample = texture2D( uCoverageMap, vCoverageTexCoord );
+	vec3 coverageTint = clamp( coverageSample.rgb * uCoverageStageColor.rgb * VertexColorRgb( uCoverageVertexColorMode ), 0.0, 1.0 );
+	float coverageAlpha = coverageSample.a * uCoverageStageColor.a * vCoverageVertexAlpha;
+	if ( uCoverageAlphaTestEnabled > 0.5 && coverageAlpha <= uCoverageAlphaTestRef ) {
+		discard;
+	}
+	if ( uCoverageSourceMode > 1.5 ) {
+		coverageAlpha = max( coverageAlpha, dot( coverageTint, vec3( 0.2126, 0.7152, 0.0722 ) ) * vCoverageVertexAlpha );
+	}
+	return clamp( coverageAlpha, 0.0, 1.0 );
+}
+
+vec3 StageAbsorption() {
+	float coverage = CoverageAmount();
+	if ( uOpacitySourceMode > 1.5 ) {
+		vec3 transmission = clamp( uStageColor.rgb * VertexColorRgb( uVertexColorMode ), 0.0, 1.0 );
+		return clamp( ( 1.0 - transmission ) * coverage * vVertexAlpha, 0.0, 0.999 );
+	}
+
+	vec4 sampleColor = texture2D( uAlphaMap, vAlphaTexCoord );
+	vec3 transmission = clamp( sampleColor.rgb * uStageColor.rgb * VertexColorRgb( uVertexColorMode ), 0.0, 1.0 );
+	return clamp( ( 1.0 - transmission ) * coverage * vVertexAlpha, 0.0, 0.999 );
 }
 
 void main() {
-	float alpha = StageOpacity();
-	if ( alpha <= uTranslucentMinAlpha ) {
+	vec3 absorption = StageAbsorption();
+	float maxAbsorption = max( absorption.r, max( absorption.g, absorption.b ) );
+	if ( maxAbsorption <= uTranslucentMinAlpha ) {
 		discard;
 	}
 
-	float tau = OpticalDepth( alpha );
+	vec3 tauColor = vec3( OpticalDepth( absorption.r ), OpticalDepth( absorption.g ), OpticalDepth( absorption.b ) );
 	float depth = clamp( length( vPointShadowVector ) / uPointShadowFar, 0.0, 1.0 );
 	float depth2 = depth * depth;
-	gl_FragColor = vec4( tau, tau * depth, tau * depth2, tau * depth2 * depth );
+	gl_FragData[0] = vec4( tauColor.r, tauColor.r * depth, tauColor.r * depth2, tauColor.r * depth2 * depth );
+	gl_FragData[1] = vec4( tauColor.g, tauColor.g * depth, tauColor.g * depth2, tauColor.g * depth2 * depth );
+	gl_FragData[2] = vec4( tauColor.b, tauColor.b * depth, tauColor.b * depth2, tauColor.b * depth2 * depth );
 }

.install/openq4/glprogs/openq4_shadow_point_translucent_caster.vs

@@ -6,11 +6,17 @@ uniform vec4 uModelMatrixRow2;
 uniform vec4 uGlobalLightOrigin;
 uniform vec4 uAlphaTexCoordS;
 uniform vec4 uAlphaTexCoordT;
+uniform vec4 uCoverageTexCoordS;
+uniform vec4 uCoverageTexCoordT;
 uniform vec2 uVertexAlphaParams;
+uniform vec2 uCoverageVertexAlphaParams;
 
 varying vec3 vPointShadowVector;
 varying vec2 vAlphaTexCoord;
+varying vec2 vCoverageTexCoord;
+varying vec3 vVertexColorRgb;
 varying float vVertexAlpha;
+varying float vCoverageVertexAlpha;
 
 void main() {
 	vec4 position = gl_Vertex;
@@ -21,6 +27,9 @@ void main() {
 		dot( position, uModelMatrixRow2 ) );
 	vPointShadowVector = worldPos - uGlobalLightOrigin.xyz;
 	vAlphaTexCoord = vec2( dot( alphaTexCoord, uAlphaTexCoordS ), dot( alphaTexCoord, uAlphaTexCoordT ) );
+	vCoverageTexCoord = vec2( dot( alphaTexCoord, uCoverageTexCoordS ), dot( alphaTexCoord, uCoverageTexCoordT ) );
+	vVertexColorRgb = gl_Color.rgb;
 	vVertexAlpha = clamp( gl_Color.a * uVertexAlphaParams.x + uVertexAlphaParams.y, 0.0, 1.0 );
+	vCoverageVertexAlpha = clamp( gl_Color.a * uCoverageVertexAlphaParams.x + uCoverageVertexAlphaParams.y, 0.0, 1.0 );
 	gl_Position = ftransform();
 }

.install/openq4/glprogs/openq4_shadow_proj_translucent_caster.fs

@@ -1,39 +1,77 @@
 #version 110
 
 uniform sampler2D uAlphaMap;
-uniform float uAlphaScale;
+uniform sampler2D uCoverageMap;
+uniform vec4 uStageColor;
+uniform vec4 uCoverageStageColor;
 uniform float uOpacitySourceMode;
+uniform float uVertexColorMode;
+uniform float uCoverageSourceMode;
+uniform float uCoverageVertexColorMode;
+uniform float uCoverageAlphaTestRef;
+uniform float uCoverageAlphaTestEnabled;
 uniform float uTranslucentMinAlpha;
 
 varying vec2 vAlphaTexCoord;
+varying vec2 vCoverageTexCoord;
+varying vec3 vVertexColorRgb;
 varying float vVertexAlpha;
+varying float vCoverageVertexAlpha;
 
 float OpticalDepth( float alpha ) {
 	return -log( max( 1.0 - clamp( alpha, 0.0, 0.999 ), 1.0e-4 ) );
 }
 
-float StageOpacity() {
-	if ( uOpacitySourceMode > 1.5 ) {
-		return clamp( uAlphaScale * vVertexAlpha, 0.0, 0.999 );
+vec3 VertexColorRgb( float mode ) {
+	if ( mode > 1.5 ) {
+		return 1.0 - vVertexColorRgb;
+	}
+	if ( mode > 0.5 ) {
+		return vVertexColorRgb;
 	}
+	return vec3( 1.0 );
+}
 
-	vec4 sampleColor = texture2D( uAlphaMap, vAlphaTexCoord );
-	float opacity = sampleColor.a;
-	if ( uOpacitySourceMode > 0.5 ) {
-		opacity = max( opacity, dot( sampleColor.rgb, vec3( 0.2126, 0.7152, 0.0722 ) ) );
+float CoverageAmount() {
+	if ( uCoverageSourceMode < 0.5 ) {
+		return 1.0;
 	}
 
-	return clamp( opacity * uAlphaScale * vVertexAlpha, 0.0, 0.999 );
+	vec4 coverageSample = texture2D( uCoverageMap, vCoverageTexCoord );
+	vec3 coverageTint = clamp( coverageSample.rgb * uCoverageStageColor.rgb * VertexColorRgb( uCoverageVertexColorMode ), 0.0, 1.0 );
+	float coverageAlpha = coverageSample.a * uCoverageStageColor.a * vCoverageVertexAlpha;
+	if ( uCoverageAlphaTestEnabled > 0.5 && coverageAlpha <= uCoverageAlphaTestRef ) {
+		discard;
+	}
+	if ( uCoverageSourceMode > 1.5 ) {
+		coverageAlpha = max( coverageAlpha, dot( coverageTint, vec3( 0.2126, 0.7152, 0.0722 ) ) * vCoverageVertexAlpha );
+	}
+	return clamp( coverageAlpha, 0.0, 1.0 );
+}
+
+vec3 StageAbsorption() {
+	float coverage = CoverageAmount();
+	if ( uOpacitySourceMode > 1.5 ) {
+		vec3 transmission = clamp( uStageColor.rgb * VertexColorRgb( uVertexColorMode ), 0.0, 1.0 );
+		return clamp( ( 1.0 - transmission ) * coverage * vVertexAlpha, 0.0, 0.999 );
+	}
+
+	vec4 sampleColor = texture2D( uAlphaMap, vAlphaTexCoord );
+	vec3 transmission = clamp( sampleColor.rgb * uStageColor.rgb * VertexColorRgb( uVertexColorMode ), 0.0, 1.0 );
+	return clamp( ( 1.0 - transmission ) * coverage * vVertexAlpha, 0.0, 0.999 );
 }
 
 void main() {
-	float alpha = StageOpacity();
-	if ( alpha <= uTranslucentMinAlpha ) {
+	vec3 absorption = StageAbsorption();
+	float maxAbsorption = max( absorption.r, max( absorption.g, absorption.b ) );
+	if ( maxAbsorption <= uTranslucentMinAlpha ) {
 		discard;
 	}
 
-	float tau = OpticalDepth( alpha );
+	vec3 tauColor = vec3( OpticalDepth( absorption.r ), OpticalDepth( absorption.g ), OpticalDepth( absorption.b ) );
 	float depth = clamp( gl_FragCoord.z, 0.0, 1.0 );
 	float depth2 = depth * depth;
-	gl_FragColor = vec4( tau, tau * depth, tau * depth2, tau * depth2 * depth );
+	gl_FragData[0] = vec4( tauColor.r, tauColor.r * depth, tauColor.r * depth2, tauColor.r * depth2 * depth );
+	gl_FragData[1] = vec4( tauColor.g, tauColor.g * depth, tauColor.g * depth2, tauColor.g * depth2 * depth );
+	gl_FragData[2] = vec4( tauColor.b, tauColor.b * depth, tauColor.b * depth2, tauColor.b * depth2 * depth );
 }

.install/openq4/glprogs/openq4_shadow_proj_translucent_caster.vs

@@ -2,14 +2,23 @@
 
 uniform vec4 uAlphaTexCoordS;
 uniform vec4 uAlphaTexCoordT;
+uniform vec4 uCoverageTexCoordS;
+uniform vec4 uCoverageTexCoordT;
 uniform vec2 uVertexAlphaParams;
+uniform vec2 uCoverageVertexAlphaParams;
 
 varying vec2 vAlphaTexCoord;
+varying vec2 vCoverageTexCoord;
+varying vec3 vVertexColorRgb;
 varying float vVertexAlpha;
+varying float vCoverageVertexAlpha;
 
 void main() {
 	vec4 alphaTexCoord = vec4( gl_MultiTexCoord0.xy, 0.0, 1.0 );
 	vAlphaTexCoord = vec2( dot( alphaTexCoord, uAlphaTexCoordS ), dot( alphaTexCoord, uAlphaTexCoordT ) );
+	vCoverageTexCoord = vec2( dot( alphaTexCoord, uCoverageTexCoordS ), dot( alphaTexCoord, uCoverageTexCoordT ) );
+	vVertexColorRgb = gl_Color.rgb;
 	vVertexAlpha = clamp( gl_Color.a * uVertexAlphaParams.x + uVertexAlphaParams.y, 0.0, 1.0 );
+	vCoverageVertexAlpha = clamp( gl_Color.a * uCoverageVertexAlphaParams.x + uCoverageVertexAlphaParams.y, 0.0, 1.0 );
 	gl_Position = ftransform();
 }

docs-user/shadow-mapping.md

@@ -153,10 +153,15 @@ Behavior:
 
 Current limits:
 - Supported stages currently include old-style alpha and premultiplied-alpha stages with explicit ST texture coordinates, plus common additive `blend add` / `GL_ONE, GL_ONE` stages.
-- Reflective pickup-orb style `texgen reflect` cubemap stages are approximated as constant-density translucent casters so MP health and megahealth orb shells can participate.
+- When a translucent shell/tint stage is layered on top of a separate explicit-ST coverage stage, OpenQ4 now reuses that coverage stage, including its alpha-test threshold when present, so layered pickup-orb and similar materials can cast shaped transmitted shadows instead of only uniform blobs.
+- Supported translucent casters now derive colored transmission from the material inputs available to that stage: texture alpha, sampled texture RGB, stage color, and applicable vertex color.
+- View-dependent reflection cubemaps are treated as tinted transmissive shells instead of using the reflected sample directly, so pickup orbs can tint transmitted light without camera-dependent shadow color shifts.
+- The current high-quality path stores separate translucent shadow moments for red, green, and blue, so each channel resolves blocker depth independently instead of sharing one grayscale depth distribution.
 - GUI/subview materials are skipped.
 - BSE/FX particles, unusual custom stage setups, and many effect-style materials are intentionally not forced into the translucent shadow pass.
+- Colored transmission is still approximate rather than a full deep-shadow solution, but it is materially closer to real tinted transmission than the earlier scalar/grayscale model.
 - This path adds extra GPU work because eligible lights render an additional translucent caster pass.
+- The feature now expects enough hardware for 3 translucent MRT attachments and 3 extra texture samplers in the receiver path; if that is unavailable, OpenQ4 disables this experimental translucent-shadow feature.
 
 Controls: