Remove unused graphics settings from EditorViewport

Eliminate redundant graphics preference fields (post-processing, shadow quality, MSAA, texture filtering, anisotropy, gamma) that were initialized but unused in `EditorViewport`. Clean up associated setting writes for consistency.

code/CMakeLists.txt

@@ -77,6 +77,7 @@ TARGET_LINK_LIBRARIES(code PUBLIC jansson)
 target_link_libraries(code PUBLIC anl)
 
 target_link_libraries(code PUBLIC imgui)
+target_link_libraries(code PUBLIC implot)
 
 IF(FSO_BUILD_WITH_OPENXR)
 	target_link_libraries(code PUBLIC OpenXR::openxr_loader)

code/bmpman/bmpman.cpp

@@ -883,6 +883,16 @@ const char *bm_get_filename(int handle) {
 	return entry->filename;
 }
 
+const char *bm_get_image_filename(int handle) {
+	auto entry = bm_get_entry(handle);
+
+	// an EFF entry stores the file of its individual image separately
+	if (entry->type == BM_TYPE_EFF)
+		return entry->info.ani.eff.filename;
+
+	return entry->filename;
+}
+
 void bm_get_filename(int bitmapnum, char *filename) {
 	if (!bm_is_valid(bitmapnum)) {
 		strcpy(filename, "");

code/bmpman/bmpman.h

@@ -436,6 +436,13 @@ void bm_get_filename(int bitmapnum, char *filename);
  */
 const char *bm_get_filename(int handle);
 
+/**
+ * @brief Gets the name of the file that holds the pixels of this bitmap
+ *
+ * This is the same as bm_get_filename(), except for an EFF. For an EFF it is the file of the individual image.
+ */
+const char *bm_get_image_filename(int handle);
+
 /**
  * @brief Unloads all used bitmaps, should only ever be called by game_shutdown()
  *

code/cmdline/cmdline.cpp

@@ -2444,10 +2444,9 @@ bool SetCmdlineParams()
 	if (gr_sync_validation_arg.found()) {
 		// Enables the Vulkan validation layer + debug messenger + synchronization
 		// validation feature (see VulkanRenderer::initializeInstance), but NOT the
-		// engine-level graphics debug output: -gr_debug additionally draws debug
-		// overlays (e.g. output_uniform_debug_data), which are unrelated to GPU
-		// sync validation and would otherwise appear as spurious on-screen
-		// artifacts. Keep this a pure GPU-validation switch.
+		// engine-level graphics debug output: -gr_debug additionally feeds extra
+		// stat groups into the ImGui frame profiler overlay (see gr_get_debug_stats),
+		// which are unrelated to GPU sync validation. Keep this a pure GPU-validation switch.
 		Cmdline_gr_sync_validation = true;
 	}
 

code/def_files/data/effects/deferred-f.sdr

@@ -26,13 +26,14 @@ layout(set = 1, binding = 1) uniform sampler2D sTextures[16];
 #define SpecBuffer sTextures[3]
 
 layout(set = 0, binding = 2) uniform sampler2DArrayShadow shadow_map;
+layout(set = 0, binding = 7) uniform sampler2DArray shadow_map_raw;
 
 #ifdef ENV_MAP
 layout(set = 0, binding = 3) uniform samplerCube sEnvmap;
 layout(set = 0, binding = 4) uniform samplerCube sIrrmap;
 #endif
 
-#ifdef RT_SHADOWS
+#if defined(RT_SHADOWS) || defined(RTAO)
 layout(set = 0, binding = 5) uniform accelerationStructureEXT shadow_tlas;
 #endif
 #else
@@ -41,6 +42,7 @@ uniform sampler2D NormalBuffer;
 uniform sampler2D PositionBuffer;
 uniform sampler2D SpecBuffer;
 uniform sampler2DArrayShadow shadow_map;
+uniform sampler2DArray shadow_map_raw;
 
 #ifdef ENV_MAP
 uniform samplerCube sEnvmap;
@@ -71,6 +73,10 @@ uniform shadowCascadeParams {
 	int cascade_count;
 	float rtShadowBiasMin;
 	float rtShadowBiasMax;
+	int rtShadowSampleCount;
+	int rtaoSampleCount;
+	float rtaoRadius;
+	float rtaoStrength;
 
 	mat4 shadow_mv_matrix;
 
@@ -80,6 +86,7 @@ uniform shadowCascadeParams {
 	mat4 shadow_proj_matrix[NUM_SHADOW_CASCADES];
 	vec4 cascade_distances[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 	vec4 smoothness_factors[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
+	vec4 penumbra_scale[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 };
 
 #ifdef VULKAN
@@ -303,6 +310,18 @@ void main()
 
 	if (lightType == LT_AMBIENT) {
 		float ao = position_buffer.w;
+#ifdef RTAO
+		{
+			// Raytraced AO multiplies into the same ao term as the baked AO maps,
+			// so the env-map/IBL ambient below darkens consistently for free.
+			// Ray origin in TLAS-relative space, as for the shadow rays below.
+			vec3 worldPos = mat3(inv_view_matrix) * position + shadow_ray_view_origin;
+			vec3 worldNormal = normalize((inv_view_matrix * vec4(normal, 0.0)).xyz);
+			float rtaoBias = computeRtShadowBias(length(position), rtShadowBiasMin, rtShadowBiasMax);
+			ao *= traceAmbientOcclusion(shadow_tlas, worldPos, worldNormal,
+				rtaoRadius, rtaoStrength, rtaoSampleCount, rtaoBias, gl_FragCoord.xy);
+		}
+#endif
 		fragmentColor.rgb = diffuseLightColor * diffColor * ao;
 
 #ifdef ENV_MAP
@@ -330,7 +349,14 @@ void main()
 			vec3 worldLightDir = normalize((inv_view_matrix * vec4(lightDir, 0.0)).xyz);
 
 			float rtShadowBias = computeRtShadowBias(length(position), rtShadowBiasMin, rtShadowBiasMax);
-			attenuation *= traceShadowRay(shadow_tlas, worldPos, worldNormal, worldLightDir, lightDist, rtShadowBias, uint(shadow_ray_cull_mask));
+			// Penumbra cone: for directional lights sourceRadius IS the tangent of the
+			// sun's angular radius ($SunAngularSize); for local lights the subtended
+			// half-angle follows from the physical source radius and the light distance.
+			float coneTan = (lightType == LT_DIRECTIONAL)
+				? sourceRadius
+				: sourceRadius / max(lightDist, 1e-3);
+			attenuation *= traceShadowRayCone(shadow_tlas, worldPos, worldNormal, worldLightDir, lightDist,
+				rtShadowBias, uint(shadow_ray_cull_mask), coneTan, rtShadowSampleCount, gl_FragCoord.xy);
 #else
 			vec4 fragShadowPos = shadow_mv_matrix * inv_view_matrix * vec4(position, 1.0);
 			vec4 fragShadowUV[NUM_SHADOW_CASCADES];
@@ -338,7 +364,7 @@ void main()
 				fragShadowUV[i] = transformToShadowMap(shadow_proj_matrix[i], i, fragShadowPos);
 			}
 
-			attenuation *= getShadowValue(shadow_map, -position.z, fragShadowUV, cascade_distances, smoothness_factors, cascade_offset, cascade_count);
+			attenuation *= getShadowValue(shadow_map, shadow_map_raw, -position.z, fragShadowUV, cascade_distances, smoothness_factors, penumbra_scale, cascade_offset, cascade_count);
 #endif
 		}
 

code/def_files/data/effects/fxaa-v.sdr

@@ -11,6 +11,7 @@ void main() {
 }
 #else
 in vec4 vertPosition;
+in vec4 vertTexCoord;
 
 out vec2 v_rcpFrame;
 #ifdef GL_ES
@@ -27,6 +28,8 @@ layout (std140) uniform genericData {
 void main() {
 	gl_Position = vertPosition;
 	v_rcpFrame = vec2(1.0/rt_w, 1.0/rt_h);
-	v_pos = vertPosition.xy*0.5 + 0.5;
+	// Use the real texcoord rather than deriving it from vertPosition: the draw call may ask for a
+	// sub-rectangle of the source texture, which the clip-space formula ignored. Matches post-v.sdr.
+	v_pos = vertTexCoord.xy;
 }
 #endif

code/def_files/data/effects/main-f.sdr

@@ -110,6 +110,10 @@ uniform shadowCascadeParams {
 	int cascade_count;
 	float rtShadowBiasMin;
 	float rtShadowBiasMax;
+	int rtShadowSampleCount;
+	int rtaoSampleCount;
+	float rtaoRadius;
+	float rtaoStrength;
 
 	mat4 shadow_mv_matrix;
 
@@ -119,6 +123,7 @@ uniform shadowCascadeParams {
 	mat4 shadow_proj_matrix[NUM_SHADOW_CASCADES];
 	vec4 cascade_distances[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 	vec4 smoothness_factors[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
+	vec4 penumbra_scale[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 };
 
 
@@ -138,6 +143,7 @@ layout(set = 1, binding = 1) uniform sampler2DArray materialTextures[16];
 #define sMiscmap materialTextures[6]
 
 layout(set = 0, binding = 2) uniform sampler2DArrayShadow shadow_map;
+layout(set = 0, binding = 7) uniform sampler2DArray shadow_map_raw;
 layout(set = 1, binding = 5) uniform sampler2D sFramebuffer;
 
 #ifdef MODEL_SDR_FLAG_RT_SHADOWS
@@ -183,6 +189,7 @@ uniform sampler2DArray sMiscmap;
 #prereplace ENDIF_FLAG_COMPILED MODEL_SDR_FLAG_MISC
 #prereplace IF_FLAG_COMPILED MODEL_SDR_FLAG_SHADOWS
 uniform sampler2DArrayShadow shadow_map;
+uniform sampler2DArray shadow_map_raw;
 #prereplace ENDIF_FLAG_COMPILED MODEL_SDR_FLAG_SHADOWS
 
 in VertexOutput {
@@ -267,7 +274,11 @@ vec3 CalculateLighting(vec3 normal, vec3 diffuseMaterial, vec3 specularMaterial,
 		if (rtShadowsActive && lights[i].light_type == LT_DIRECTIONAL && shadowedDirectionalCount < MAX_RT_SHADOW_LIGHTS) {
 			vec3 worldSunDir = normalize((invView * vec4(lights[i].position.xyz, 0.0)).xyz);
 			float rtShadowBias = computeRtShadowBias(length(vertIn.position.xyz), rtShadowBiasMin, rtShadowBiasMax);
-			shadow = traceShadowRay(shadow_tlas, worldPos, worldNormal, worldSunDir, RT_SHADOW_MAX_DISTANCE, rtShadowBias, uint(shadow_ray_cull_mask));
+			// For directional lights ml_sourceRadius is the tangent of the sun's
+			// angular radius ($SunAngularSize) -- 0 keeps hard shadows.
+			shadow = traceShadowRayCone(shadow_tlas, worldPos, worldNormal, worldSunDir, RT_SHADOW_MAX_DISTANCE,
+				rtShadowBias, uint(shadow_ray_cull_mask), lights[i].ml_sourceRadius,
+				rtShadowSampleCount, gl_FragCoord.xy);
 			++shadowedDirectionalCount;
 		} else {
 			shadow = 1.0;
@@ -439,7 +450,7 @@ void main()
 			// up to MAX_RT_SHADOW_LIGHTS) inside CalculateLighting()'s loop instead --
 			// this single shared `shadow` value only matters for the CSM fallback below.
 			#ifndef MODEL_SDR_FLAG_RT_SHADOWS
-				shadow = getShadowValue(shadow_map, -vertIn.position.z, vertIn.shadowUV, cascade_distances, smoothness_factors, cascade_offset, cascade_count);
+				shadow = getShadowValue(shadow_map, shadow_map_raw, -vertIn.position.z, vertIn.shadowUV, cascade_distances, smoothness_factors, penumbra_scale, cascade_offset, cascade_count);
 			#endif
 			#prereplace ENDIF_FLAG //MODEL_SDR_FLAG_SHADOWS
 			baseColor.rgb = CalculateLighting(normal, baseColor.rgb, specColor.rgb, glossData, fresnelFactor, shadow, aoFactors.x);

code/def_files/data/effects/main-v.sdr

@@ -125,6 +125,10 @@ uniform shadowCascadeParams {
 	int cascade_count;
 	float rtShadowBiasMin;
 	float rtShadowBiasMax;
+	int rtShadowSampleCount;
+	int rtaoSampleCount;
+	float rtaoRadius;
+	float rtaoStrength;
 
 	mat4 shadow_mv_matrix;
 
@@ -134,6 +138,7 @@ uniform shadowCascadeParams {
 	mat4 shadow_proj_matrix[NUM_SHADOW_CASCADES];
 	vec4 cascade_distances[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 	vec4 smoothness_factors[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
+	vec4 penumbra_scale[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 };
 
 #ifdef VULKAN

code/def_files/data/effects/shadow_map-g.sdr

@@ -14,11 +14,18 @@ layout (triangle_strip, max_vertices = 3) out;
 layout(invocations = NUM_SHADOW_CASCADES) in;
 #endif
 
-layout (std140) uniform shadowCascadeParams {
-    int cascade_offset;
-    int cascade_count;
-    float rtShadowBiasMin;
-    float rtShadowBiasMax;
+// OpenGL-only: the Vulkan backend has no geometry-shader stage, and disables the
+// shadow pass outright when it can't write gl_Layer from the vertex shader, so it
+// never requests GEOMETRY_FALLBACK. Hence no Vulkan set/binding qualifier here.
+layout(std140) uniform shadowCascadeParams {
+	int cascade_offset;
+	int cascade_count;
+	float rtShadowBiasMin;
+	float rtShadowBiasMax;
+	int rtShadowSampleCount;
+	int rtaoSampleCount;
+	float rtaoRadius;
+	float rtaoStrength;
 
 	mat4 shadow_mv_matrix;
 
@@ -28,6 +35,7 @@ layout (std140) uniform shadowCascadeParams {
 	mat4 shadow_proj_matrix[NUM_SHADOW_CASCADES];
 	vec4 cascade_distances[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 	vec4 smoothness_factors[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
+	vec4 penumbra_scale[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 };
 
 in VertexOutput {

code/def_files/data/effects/shadow_map-v.sdr

@@ -45,10 +45,14 @@ layout(set = 0, binding = 6, std140)
 layout(std140)
 #endif
 uniform shadowCascadeParams {
-    int cascade_offset;
-    int cascade_count;
-    float rtShadowBiasMin;
-    float rtShadowBiasMax;
+	int cascade_offset;
+	int cascade_count;
+	float rtShadowBiasMin;
+	float rtShadowBiasMax;
+	int rtShadowSampleCount;
+	int rtaoSampleCount;
+	float rtaoRadius;
+	float rtaoStrength;
 
 	mat4 shadow_mv_matrix;
 
@@ -58,6 +62,7 @@ uniform shadowCascadeParams {
 	mat4 shadow_proj_matrix[NUM_SHADOW_CASCADES];
 	vec4 cascade_distances[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 	vec4 smoothness_factors[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
+	vec4 penumbra_scale[(NUM_SHADOW_CASCADES + 4 - 1) / 4];
 };
 
 #ifdef VULKAN

code/def_files/data/effects/shadows.sdr

@@ -6,33 +6,47 @@
 #define SAMPLES_PCSS 1
 #endif
 
-float samplePoissonPCSS(sampler2DArrayShadow shadow_map, vec4 shadowUV, float maxUVOffset)
-{
+// Full 16-tap Poisson disc. Unconditional (independent of SMOOTH_PCSS) because it has three
+// consumers with different needs: samplePoissonPCSS() takes the first SAMPLES_PCSS of these,
+// pcssBlockerSearch() always wants 8 (every second tap) regardless of SAMPLES_PCSS (a
+// blocker search only needs a coarse estimate), and the raytraced cone/AO sampling further
+// below always
+// wants the full spread. Keeping one table means none of those three can end up indexing
+// past a table sized for a different consumer.
+const vec2 poissonDisc16[16] = vec2[](
+	vec2(-0.76275, -0.3432573),
+	vec2(-0.5226235, -0.8277544),
+	vec2(-0.3780261, 0.01528688),
+	vec2(-0.7742821, 0.4245702),
+	vec2(0.04196143, -0.02622231),
+	vec2(-0.2974772, -0.4722782),
+	vec2(-0.516093, 0.71495),
+	vec2(-0.3257416, 0.3910343),
+	vec2(0.2705966, 0.6670476),
+	vec2(0.4918377, 0.1853267),
+	vec2(0.4428544, -0.6251478),
+	vec2(-0.09204347, 0.9267113),
+	vec2(0.391505, -0.2558275),
+	vec2(0.05605913, -0.7570801),
+	vec2(0.81772, -0.02475523),
+	vec2(0.6890262, 0.5191521)
+);
+
+// Low-quality raster PCSS fallback: a single centered sample (i.e. no offset at all) rather
+// than poissonDisc16[0], which is just one arbitrary tap among sixteen and no better centered
+// than any other.
+const vec2 poissonDiscCenter[1] = vec2[](vec2(0.0, 0.0));
+
+// samplePoissonPCSS()'s tap table: the full disc when taking all SAMPLES_PCSS == 16 of them,
+// or the single centered sample when SAMPLES_PCSS == 1.
 #if SMOOTH_PCSS
-	vec2 poissonDisc[16] = vec2[](
-		vec2(-0.76275, -0.3432573),
-		vec2(-0.5226235, -0.8277544),
-		vec2(-0.3780261, 0.01528688),
-		vec2(-0.7742821, 0.4245702),
-		vec2(0.04196143, -0.02622231),
-		vec2(-0.2974772, -0.4722782),
-		vec2(-0.516093, 0.71495),
-		vec2(-0.3257416, 0.3910343),
-		vec2(0.2705966, 0.6670476),
-		vec2(0.4918377, 0.1853267),
-		vec2(0.4428544, -0.6251478),
-		vec2(-0.09204347, 0.9267113),
-		vec2(0.391505, -0.2558275),
-		vec2(0.05605913, -0.7570801),
-		vec2(0.81772, -0.02475523),
-		vec2(0.6890262, 0.5191521)
-	);
+#define poissonDisc poissonDisc16
 #else
-	vec2 poissonDisc[1] = vec2[](
-		vec2(0.0,0.0)
-	);
+#define poissonDisc poissonDiscCenter
 #endif
 
+float samplePoissonPCSS(sampler2DArrayShadow shadow_map, vec4 shadowUV, float maxUVOffset)
+{
 	float visibility = 0.0f;
 	for (int i=0; i<SAMPLES_PCSS; i++) {
 	    vec4 uv = shadowUV;
@@ -42,8 +56,82 @@ float samplePoissonPCSS(sampler2DArrayShadow shadow_map, vec4 shadowUV, float ma
 	return visibility * (1.0f/float(SAMPLES_PCSS));
 }
 
-float getShadowValue(sampler2DArrayShadow shadow_map, float depth, vec4 shadowUV[NUM_SHADOW_CASCADES],
+// PCSS blocker search: raw (non-compare) depth taps within searchRadiusUV, using every
+// second tap of poissonDisc16. The first 8 taps are mostly on one side (x < 0), so they
+// would search the penumbra on one side only. This is always the full-spread table, not
+// samplePoissonPCSS()'s poissonDisc --
+// a blocker search only needs a coarse estimate, not the final filtered result, but it needs
+// that estimate regardless of how many taps the raster PCSS path itself is set to take).
+// "Blocker" = stored < receiverDepth, matching the GL_LEQUAL/eLessOrEqual compare convention
+// the hardware PCF sampler already uses (visible iff Dref <= stored) -- see the compare-sampler
+// setup in gropengltnl.cpp / VulkanPostProcessingShadow.cpp.
+// A negative return means "no blockers found", which the average blocker depth (always >= 0)
+// can't otherwise be distinguished from "found some at depth 0".
+float pcssBlockerSearch(sampler2DArray shadow_map_raw, vec4 shadowUV, float searchRadiusUV)
+{
+	float sum = 0.0;
+	int blockerCount = 0;
+	for (int i = 0; i < 8; i++) {
+		vec2 uv = shadowUV.xy + poissonDisc16[i * 2] * searchRadiusUV;
+		float sampled = texture(shadow_map_raw, vec3(uv, shadowUV.z)).r;
+		if (sampled < shadowUV.w) {
+			sum += sampled;
+			blockerCount++;
+		}
+	}
+	return blockerCount > 0 ? (sum / float(blockerCount)) : -1.0;
+}
+
+// Computes the PCSS penumbra radius for one cascade sample: a blocker search followed by
+// the orthographic-light penumbra formula (see shadow_smoothness_scale()'s doc comment in
+// shadows.cpp for the derivation), clamped to [1 texel, smoothnessCeiling]. penumbraScale is
+// Shadow_penumbra_scale[cascade] -- a negative value is the "unsupported or user-disabled"
+// sentinel (see shadow_contact_hardening_enabled() in shadows.cpp), in which case this
+// returns smoothnessCeiling immediately: bit-identical to the fixed-width behavior from
+// before contact hardening existed, and skips the blocker search's extra texture reads.
+float pcssPenumbraRadius(sampler2DArrayShadow shadow_map, sampler2DArray shadow_map_raw,
+						  vec4 shadowUV, float penumbraScale, float smoothnessCeiling)
+{
+	float texelFloor = 1.0 / float(textureSize(shadow_map, 0).x);
+
+	if (penumbraScale < 0.0) {
+		return smoothnessCeiling;
+	}
+
+	float avgBlockerDepth = pcssBlockerSearch(shadow_map_raw, shadowUV, smoothnessCeiling);
+	if (avgBlockerDepth < 0.0) {
+		// The sparse 8-tap search found nothing, but that doesn't prove there's no thin
+		// occluder nearby -- run the full PCF at the hardest radius rather than assuming
+		// fully lit, so a missed thin blocker still reads as an edge instead of popping to
+		// no shadow at all.
+		return texelFloor;
+	}
+
+	float deltaDepth = max(shadowUV.w - avgBlockerDepth, 0.0);
+	return clamp(deltaDepth * penumbraScale, texelFloor, smoothnessCeiling);
+}
+
+// PCSS-filtered shadow visibility for a single cascade: looks up its penumbra radius (see
+// pcssPenumbraRadius()) and samples the shadow map at that radius. Factored out of
+// getShadowValue() below so the cascade-index unpacking (v/i from cascade/4, cascade%4) and
+// the penumbra-radius lookup each appear once, whichever of getShadowValue()'s two return
+// paths runs.
+float shadowVisibilityForCascade(sampler2DArrayShadow shadow_map, sampler2DArray shadow_map_raw,
+	vec4 shadowUV, int cascade, vec4 smoothness_factors[(NUM_SHADOW_CASCADES + 4 - 1) / 4],
+	vec4 penumbra_scale[(NUM_SHADOW_CASCADES + 4 - 1) / 4])
+{
+	int v = cascade / 4;
+	int i = cascade % 4;
+
+	float radius = pcssPenumbraRadius(shadow_map, shadow_map_raw, shadowUV,
+		penumbra_scale[v][i], smoothness_factors[v][i]);
+
+	return samplePoissonPCSS(shadow_map, shadowUV, radius);
+}
+
+float getShadowValue(sampler2DArrayShadow shadow_map, sampler2DArray shadow_map_raw, float depth, vec4 shadowUV[NUM_SHADOW_CASCADES],
 					 vec4 cascade_distances[(NUM_SHADOW_CASCADES + 4 - 1) / 4], vec4 smoothness_factors[(NUM_SHADOW_CASCADES + 4 - 1) / 4],
+					 vec4 penumbra_scale[(NUM_SHADOW_CASCADES + 4 - 1) / 4],
 					 int cascade_offset, int cascade_count)
 {
 	int cascade = cascade_offset + cascade_count;
@@ -52,19 +140,19 @@ float getShadowValue(sampler2DArrayShadow shadow_map, float depth, vec4 shadowUV
 	}
 	if (cascade >= cascade_offset + cascade_count || cascade < cascade_offset) return 1.0;
 
-    int cascade_v = cascade / 4;
-    int cascade_i = cascade % 4;
-
 	float cascade_start = (cascade > cascade_offset) ? cascade_distances[(cascade - 1) / 4][(cascade - 1) % 4] : 0.0;
-	float cascade_end = cascade_distances[cascade_v][cascade_i];
+	float cascade_end = cascade_distances[cascade / 4][cascade % 4];
 	float dist_threshold = (cascade_end - cascade_start) * 0.2;
 
 	if (cascade_end - dist_threshold > depth || cascade >= cascade_offset + cascade_count - 1)
-		return samplePoissonPCSS(shadow_map, shadowUV[cascade], smoothness_factors[cascade_v][cascade_i]);
+		return shadowVisibilityForCascade(shadow_map, shadow_map_raw, shadowUV[cascade], cascade,
+			smoothness_factors, penumbra_scale);
 
 	return mix(
-		samplePoissonPCSS(shadow_map, shadowUV[cascade], smoothness_factors[cascade_v][cascade_i]),
-		samplePoissonPCSS(shadow_map, shadowUV[cascade + 1], smoothness_factors[(cascade + 1) / 4][(cascade + 1) % 4]),
+		shadowVisibilityForCascade(shadow_map, shadow_map_raw, shadowUV[cascade], cascade,
+			smoothness_factors, penumbra_scale),
+		shadowVisibilityForCascade(shadow_map, shadow_map_raw, shadowUV[cascade + 1], cascade + 1,
+			smoothness_factors, penumbra_scale),
 		smoothstep(cascade_end - dist_threshold, cascade_end, depth));
 }
 // Raytraced shadow test via inline ray query against the shadow TLAS. Only
@@ -79,7 +167,7 @@ float getShadowValue(sampler2DArrayShadow shadow_map, float depth, vec4 shadowUV
 // in deferred-f.sdr/main-f.sdr references it regardless of which shadow method is active.
 const float RT_SHADOW_MAX_DISTANCE = 10000.0;
 
-#if defined(MODEL_SDR_FLAG_RT_SHADOWS) || defined(RT_SHADOWS)
+#if defined(MODEL_SDR_FLAG_RT_SHADOWS) || defined(RT_SHADOWS) || defined(RTAO)
 #extension GL_EXT_ray_query : require
 
 // Ray origin bias grows with distance from the camera, between the rtShadowBiasMin/
@@ -132,6 +220,141 @@ float traceShadowRay(accelerationStructureEXT tlas, vec3 worldPos, vec3 worldNor
 
 	return (rayQueryGetIntersectionTypeEXT(rq, true) == gl_RayQueryCommittedIntersectionNoneEXT) ? 1.0 : 0.0;
 }
+
+// Penumbra/AO sampling: at most this many rays per fragment per light, matching the size of
+// poissonDisc16 above (the RT cone/AO sampling below always wants the full 16-tap spread,
+// independent of SAMPLES_PCSS/SMOOTH_PCSS -- see the comment on poissonDisc16). rtShadowSampleCount/
+// rtaoSampleCount (shadowCascadeParams) are clamped against it, so a bad uniform value can't
+// index out of the pattern.
+#define RT_SHADOW_MAX_SAMPLES 16
+
+// Orthonormal basis spanning the plane perpendicular to axis (a unit vector).
+void rtBuildOnb(vec3 axis, out vec3 tangent, out vec3 bitangent)
+{
+	vec3 up = (abs(axis.z) < 0.999) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+	tangent = normalize(cross(up, axis));
+	bitangent = cross(axis, tangent);
+}
+
+// Interleaved gradient noise (Jimenez 2014) -> per-fragment [0,1) value used to
+// rotate the shared disc pattern. Callers pass gl_FragCoord.xy as the seed; it is
+// a parameter rather than read here because this file is also compiled in vertex
+// stages, where gl_FragCoord doesn't exist.
+float rtInterleavedGradientNoise(vec2 seed)
+{
+	return fract(52.9829189 * fract(dot(seed, vec2(0.06711056, 0.00583715))));
+}
+
+// Soft (penumbra) variant of traceShadowRay: averages up to sampleCount occlusion
+// rays whose directions are jittered inside a cone of half-angle
+// atan(coneHalfAngleTan) around worldLightDir. Callers derive coneHalfAngleTan
+// from the light's source radius -- for directional lights the light's
+// source_radius IS the tangent of its angular radius (see $SunAngularSize in
+// stars.tbl / starfield.cpp), for local lights it's sourceRadius / lightDist --
+// so penumbras widen with occluder distance like a real area light's would.
+//
+// cullMask has the same meaning as in traceShadowRay().
+//
+// noiseSeed decorrelates the sample pattern between fragments (see
+// rtInterleavedGradientNoise() for why it's a parameter). There is no temporal
+// accumulation in the engine, so the penumbra must fully resolve in this one
+// pass: the disc pattern is fixed and only its per-fragment rotation is
+// randomized, trading a little visible grain for stable, flicker-free output.
+//
+// sampleCount <= 1 or coneHalfAngleTan <= 0.0 falls back to the single hard ray,
+// bit-identical to traceShadowRay() -- that keeps the pre-penumbra look and cost
+// as the default (mods opt in via source radii, users via the sample option).
+float traceShadowRayCone(accelerationStructureEXT tlas, vec3 worldPos, vec3 worldNormal, vec3 worldLightDir,
+	float tMax, float bias, uint cullMask, float coneHalfAngleTan, int sampleCount, vec2 noiseSeed)
+{
+	if (sampleCount <= 1 || coneHalfAngleTan <= 0.0) {
+		return traceShadowRay(tlas, worldPos, worldNormal, worldLightDir, tMax, bias, cullMask);
+	}
+
+	vec3 origin = worldPos + worldNormal * bias;
+	vec3 direction = normalize(worldLightDir);
+
+	vec3 tangent, bitangent;
+	rtBuildOnb(direction, tangent, bitangent);
+
+	float rotAngle = rtInterleavedGradientNoise(noiseSeed) * 6.2831853;
+	float cosR = cos(rotAngle);
+	float sinR = sin(rotAngle);
+
+	int samples = min(sampleCount, RT_SHADOW_MAX_SAMPLES);
+	float visibility = 0.0;
+	for (int i = 0; i < samples; ++i) {
+		vec2 p = poissonDisc16[i];
+		p = vec2(p.x * cosR - p.y * sinR, p.x * sinR + p.y * cosR);
+		vec3 sampleDir = normalize(direction + (tangent * p.x + bitangent * p.y) * coneHalfAngleTan);
+
+		rayQueryEXT rq;
+		rayQueryInitializeEXT(rq, tlas, gl_RayFlagsOpaqueEXT | gl_RayFlagsTerminateOnFirstHitEXT,
+			cullMask, origin, 0.001, sampleDir, tMax);
+		while (rayQueryProceedEXT(rq)) {}
+
+		if (rayQueryGetIntersectionTypeEXT(rq, true) == gl_RayQueryCommittedIntersectionNoneEXT) {
+			visibility += 1.0;
+		}
+	}
+	return visibility / float(samples);
+}
+
+// Raytraced ambient occlusion: averages up to sampleCount occlusion rays of
+// length `radius` over the hemisphere around worldNormal and returns ambient
+// visibility in [0,1] (1 = fully open), shaped by pow(visibility, strength).
+// Mapping the shared disc pattern up onto the hemisphere (z = sqrt(1-|p|^2))
+// makes the samples cosine-weighted, matching the diffuse ambient term being
+// occluded. radius/strength come from the mod's lighting profile ($RTAO Radius /
+// $RTAO Strength); scene scale varies too much (fighters vs. capships) for a
+// built-in constant.
+//
+// Hits accumulate with a (1 - t/radius) falloff so geometry entering the radius
+// occludes gradually instead of popping. That needs the *closest* hit's t, so
+// these rays deliberately omit gl_RayFlagsTerminateOnFirstHitEXT (any-hit t
+// would make the falloff arbitrary); the extra traversal cost is small because
+// tMax = radius keeps the rays short.
+//
+// sampleCount < 1, radius <= 0, or strength <= 0 returns 1.0 (no occlusion) --
+// callers gate on the RTAO shader variant, this just keeps bad uniforms benign.
+float traceAmbientOcclusion(accelerationStructureEXT tlas, vec3 worldPos, vec3 worldNormal,
+	float radius, float strength, int sampleCount, float bias, vec2 noiseSeed)
+{
+	if (sampleCount < 1 || radius <= 0.0 || strength <= 0.0) {
+		return 1.0;
+	}
+
+	vec3 origin = worldPos + worldNormal * bias;
+
+	vec3 tangent, bitangent;
+	rtBuildOnb(worldNormal, tangent, bitangent);
+
+	float rotAngle = rtInterleavedGradientNoise(noiseSeed) * 6.2831853;
+	float cosR = cos(rotAngle);
+	float sinR = sin(rotAngle);
+
+	int samples = min(sampleCount, RT_SHADOW_MAX_SAMPLES);
+	float occlusion = 0.0;
+	for (int i = 0; i < samples; ++i) {
+		vec2 p = poissonDisc16[i];
+		p = vec2(p.x * cosR - p.y * sinR, p.x * sinR + p.y * cosR);
+		vec3 sampleDir = normalize(tangent * p.x + bitangent * p.y
+			+ worldNormal * sqrt(max(1.0 - dot(p, p), 0.0)));
+
+		rayQueryEXT rq;
+		rayQueryInitializeEXT(rq, tlas, gl_RayFlagsOpaqueEXT,
+			0xFF, origin, 0.001, sampleDir, radius);
+		while (rayQueryProceedEXT(rq)) {}
+
+		if (rayQueryGetIntersectionTypeEXT(rq, true) != gl_RayQueryCommittedIntersectionNoneEXT) {
+			float hitT = rayQueryGetIntersectionTEXT(rq, true);
+			occlusion += 1.0 - clamp(hitT / radius, 0.0, 1.0);
+		}
+	}
+
+	float visibility = clamp(1.0 - occlusion / float(samples), 0.0, 1.0);
+	return pow(visibility, strength);
+}
 #endif
 
 vec4 transformToShadowMap(mat4 shadow_proj_matrix, int i, vec4 pos)

code/graphics/2d.cpp

@@ -22,6 +22,7 @@
 #include "material.h"
 #include "matrix.h"
 
+#include "bmpman/bmpman.h"
 #include "cmdline/cmdline.h"
 #include "debugconsole/console.h"
 #include "executor/global_executors.h"
@@ -42,6 +43,7 @@
 #include "render/3d.h"
 #include "scripting/hook_api.h"
 #include "scripting/scripting.h"
+#include "tracing/ProfilerOverlay.h"
 #include "tracing/tracing.h"
 #include "utils/boost/hash_combine.h"
 #include "utils/string_utils.h"
@@ -83,6 +85,7 @@ gr_capability_def gr_capabilities[] = {
 	GR_CAPABILITY_ENTRY(INSTANCED_RENDERING),
 	GR_CAPABILITY_ENTRY(FAST_SHADOWS),
 	GR_CAPABILITY_ENTRY(RAYTRACED_SHADOWS),
+	GR_CAPABILITY_ENTRY(SHADOW_CONTACT_HARDENING),
 };
 
 const size_t gr_capabilities_num = sizeof(gr_capabilities) / sizeof(gr_capabilities[0]);
@@ -924,6 +927,29 @@ bool gr_is_smaa_mode(AntiAliasMode mode) {
 	return mode == AntiAliasMode::SMAA_Low || mode == AntiAliasMode::SMAA_Medium || mode == AntiAliasMode::SMAA_High || mode == AntiAliasMode::SMAA_Ultra;
 }
 
+SCP_vector<float> gr_get_supported_anisotropy_levels()
+{
+	float max;
+	if (!gr_get_property(gr_property::MAX_ANISOTROPY, &max)) {
+		return {};
+	}
+
+	if (max <= 2.0f) {
+		return {};
+	}
+
+	SCP_vector<float> out;
+
+	// We assume here that the anisotropy levels are powers of two...
+	float current = 1.0f;
+	while (current <= max) {
+		out.push_back(current);
+		current *= 2.0f;
+	}
+
+	return out;
+}
+
 static void parse_post_processing_func()
 {
 	bool value;
@@ -1707,6 +1733,13 @@ void gr_screen_resize(int width, int height)
 	gr_screen.save_max_h_unscaled_zoomed = gr_screen.max_h_unscaled_zoomed;
 
 	gr_setup_viewport();
+
+	// The offscreen targets that back the scene/post-processing pipeline were sized for the old
+	// gr_screen; give the backend a chance to grow them before anything renders at the new size.
+	// Backends that already handle this elsewhere (Vulkan, via recreateSwapChain()) leave it unset.
+	if (gr_screen.gf_resize_render_targets) {
+		gr_screen.gf_resize_render_targets();
+	}
 }
 
 void gr_window_to_render_pos(float& x, float& y)
@@ -3263,24 +3296,38 @@ void gr_set_bitmap(int bitmap_num, int alphablend_mode, int bitblt_mode, float a
 	gr_screen.current_bitmap          = bitmap_num;
 }
 
-static void output_uniform_debug_data()
+gr_debug_stats gr_get_debug_stats()
 {
-	if (gr_screen.mode == GraphicsAPI::Stub) {
-		return;
+	gr_debug_stats stats;
+
+	if (!Cmdline_graphics_debug_output) {
+		return stats;
 	}
 
-	int line_height = gr_get_font_height() + 1;
+	if (UniformBufferManager) {
+		stats.uniform_buffer_valid = true;
+		stats.uniform_buffer_size = UniformBufferManager->getBufferSize();
+		stats.uniform_buffer_used = UniformBufferManager->getCurrentlyUsedSize();
+	}
 
-	gr_set_color_fast(&Color_bright_white);
+	gr_screen.gf_get_debug_stats(stats);
 
-	gr_printf_no_resize(gr_screen.center_offset_x + 20, gr_screen.center_offset_y + 160,
-	                    "Uniform buffer size: " SIZE_T_ARG, UniformBufferManager->getBufferSize());
-	gr_printf_no_resize(gr_screen.center_offset_x + 20, gr_screen.center_offset_y + 160 + line_height,
-	                    "Currently used data: " SIZE_T_ARG, UniformBufferManager->getCurrentlyUsedSize());
+	return stats;
 }
 
+static bool Imgui_frame_active = false;
+
 void gr_imgui_begin_frame()
 {
+	if (Imgui_frame_active) {
+		return;
+	}
+
+	// The stub renderer (standalone server) never assigns the ImGui entry points.
+	if (!gr_screen.gf_imgui_new_frame || !ImGui::GetCurrentContext()) {
+		return;
+	}
+
 	gr_imgui_new_frame();      // renderer backend (OpenGL/Vulkan)
 	ImGui_ImplSDL3_NewFrame(); // platform backend, derives the display size from the SDL window
 
@@ -3298,6 +3345,23 @@ void gr_imgui_begin_frame()
 	}
 
 	ImGui::NewFrame();
+	Imgui_frame_active = true;
+}
+
+void gr_imgui_end_frame()
+{
+	if (!Imgui_frame_active) {
+		return;
+	}
+
+	ImGui::Render();
+	gr_imgui_render_draw_data();
+	Imgui_frame_active = false;
+}
+
+bool gr_imgui_frame_active()
+{
+	return Imgui_frame_active;
 }
 
 void gr_flip(bool execute_scripting)
@@ -3318,9 +3382,13 @@ void gr_flip(bool execute_scripting)
 
 	model_process_cached_ui_render_instances();
 
-	if (Cmdline_graphics_debug_output) {
-		output_uniform_debug_data();
-	}
+	// Every presented frame drains the frame profiler and contributes the overlay window to
+	// this frame's ImGui pass. Doing it here rather than per game state is what keeps the
+	// profiler's event buffer bounded: collection is global, so the drain has to be too.
+	tracing::profiler_overlay_frame();
+
+	// Closes whatever ImGui frame the overlay (or the lab, or the options screen) opened.
+	gr_imgui_end_frame();
 
 	// IMPORTANT: No rendering may happen after this point until gf_flip()/gr_setup_frame().
 	// gr_reset_immediate_buffer() resets the write offset to 0, so any subsequent immediate
@@ -3589,6 +3657,30 @@ void gr_heap_deallocate(GpuHeap heap_type, size_t data_offset)
 	gpuHeap->freeGpuData(data_offset);
 }
 
+gr_memory_stats gr_get_memory_stats()
+{
+	gr_memory_stats stats;
+
+	// gpu_heaps[] entries stay null when gpu_heap_init() early-returned (GraphicsAPI::Stub, e.g.
+	// a build with both graphics backends disabled), so this must not assume a live heap.
+	auto vertex_heap = get_gpu_heap(GpuHeap::ModelVertex);
+	auto index_heap = get_gpu_heap(GpuHeap::ModelIndex);
+	if (vertex_heap != nullptr && index_heap != nullptr) {
+		stats.model_heap_valid = true;
+		stats.model_vertex_heap_used = vertex_heap->usedBytes();
+		stats.model_vertex_heap_size = vertex_heap->bufferSize();
+		stats.model_index_heap_used = index_heap->usedBytes();
+		stats.model_index_heap_size = index_heap->bufferSize();
+	}
+
+	stats.locked_bitmap_ram_valid = true;
+	stats.locked_bitmap_ram_bytes = bm_texture_ram;
+
+	gr_screen.gf_get_memory_stats(stats);
+
+	return stats;
+}
+
 void gr_set_gamma(float gamma)
 {
 	if (gr_screen.mode == GraphicsAPI::Stub) {

code/graphics/2d.h

@@ -262,6 +262,7 @@ enum shader_type {
 
 #define SDR_FLAG_ENV_MAP (1 << 0)
 #define SDR_FLAG_DEFERRED_RT_SHADOWS (1 << 1)
+#define SDR_FLAG_DEFERRED_RTAO (1 << 2)
 
 #define SDR_FLAG_SHADOW_FALLBACK (1 << 0)
 
@@ -370,7 +371,12 @@ enum class gr_capability {
 	CAPABILITY_INSTANCED_RENDERING,
 	CAPABILITY_FAST_SHADOWS,
 	CAPABILITY_QUERIES_REUSABLE,
-	CAPABILITY_RAYTRACED_SHADOWS
+	CAPABILITY_RAYTRACED_SHADOWS,
+	// A second, non-compare sampler bound to the shadow map for raw depth reads, needed by
+	// the shadow-map PCSS blocker search. Vulkan always has this (samplers are independent
+	// of images there); OpenGL needs GL 3.3 (glGenSamplers/glBindSampler), since the compare mode is
+	// otherwise texture-object state shared by every sampler bound to that texture.
+	CAPABILITY_SHADOW_CONTACT_HARDENING
 };
 
 struct gr_capability_def {
@@ -690,6 +696,56 @@ enum class BufferUsageHint { Static, Dynamic, Streaming, PersistentMapping };
  */
 typedef void* gr_sync;
 
+/**
+ * @brief Per-backend diagnostic counters, populated only when -gr_debug is active
+ *
+ * Each stat group carries its own "valid" flag since not every backend collects every
+ * group (e.g. per-draw-call counters currently only exist in the Vulkan backend). See
+ * gr_get_debug_stats().
+ */
+struct gr_debug_stats {
+	bool uniform_buffer_valid = false;
+	size_t uniform_buffer_size = 0;
+	size_t uniform_buffer_used = 0;
+
+	bool draw_stats_valid = false;
+	int draw_calls = 0;
+	int draw_indexed_calls = 0;
+	int total_vertices = 0;
+	int total_indices = 0;
+	int apply_material_calls = 0;
+	int apply_material_failures = 0;
+	int no_pipeline_skips = 0;
+	int descriptor_sets_allocated = 0;
+	int descriptor_writes = 0;
+	size_t pipeline_count = 0;
+	int on_demand_texture_uploads = 0;
+};
+
+/**
+ * @brief Cross-backend memory usage snapshot for the profiler overlay's memory panel
+ *
+ * Unlike gr_debug_stats, this is always populated when queried (no -gr_debug gate) -- memory
+ * usage is meant to be visible to anyone with the profiler overlay open. Each group still carries
+ * its own "valid" flag since not every backend/build collects every group (e.g. both graphics
+ * backends disabled at build time). See gr_get_memory_stats().
+ */
+struct gr_memory_stats {
+	bool model_heap_valid = false;
+	size_t model_vertex_heap_used = 0;
+	size_t model_vertex_heap_size = 0;
+	size_t model_index_heap_used = 0;
+	size_t model_index_heap_size = 0;
+
+	bool locked_bitmap_ram_valid = false;
+	size_t locked_bitmap_ram_bytes = 0;
+
+	bool gpu_purpose_valid = false;
+	size_t gpu_texture_bytes = 0;
+	size_t gpu_geometry_bytes = 0;
+	size_t gpu_render_target_bytes = 0;
+};
+
 typedef struct screen {
 	int max_w = 0, max_h = 0; // Width and height
 	int max_w_unscaled = 0, max_h_unscaled = 0;
@@ -861,6 +917,12 @@ typedef struct screen {
 	std::function<void()> gf_scene_texture_end;
 	std::function<void()> gf_copy_effect_texture;
 
+	// Grow the offscreen render targets that back the scene/post-processing pipeline to cover the
+	// current gr_screen, if they don't already. Called from gr_screen_resize(). Optional: the
+	// Vulkan backend leaves this unset because VulkanRenderer::recreateSwapChain() already owns
+	// resizing its extent-sized targets.
+	std::function<void()> gf_resize_render_targets;
+
 	std::function<void(int zbias)> gf_zbias;
 
 	std::function<void(int)> gf_set_fill_mode;
@@ -963,6 +1025,14 @@ typedef struct screen {
 	std::function<void(const char* name)> gf_push_debug_group;
 	std::function<void()> gf_pop_debug_group;
 
+	// Fills in whichever debug_stats groups this backend collects. Defaults to a no-op
+	// so backends without per-draw-call counters (OpenGL, stub) don't have to assign it.
+	std::function<void(gr_debug_stats& stats)> gf_get_debug_stats = [](gr_debug_stats&) {};
+
+	// Fills in whichever memory_stats groups this backend collects (GPU-purpose byte totals).
+	// Defaults to a no-op so backends without per-purpose tagging don't have to assign it.
+	std::function<void(gr_memory_stats& stats)> gf_get_memory_stats = [](gr_memory_stats&) {};
+
 	std::function<int()> gf_create_query_object;
 	std::function<void(int obj, QueryType type)> gf_query_value;
 	std::function<bool(int obj)> gf_query_value_available;
@@ -1161,6 +1231,23 @@ bool gr_is_screenshot_requested();
 //#define gr_flip				GR_CALL(gr_screen.gf_flip)
 void gr_flip(bool execute_scripting = true);
 
+/**
+ * @brief Collects whichever graphics-API debug stats are available for the active backend
+ *
+ * Returns a default-constructed (all-invalid) gr_debug_stats unless -gr_debug is active. Safe
+ * to call every frame regardless of backend or debug flag.
+ */
+gr_debug_stats gr_get_debug_stats();
+
+/**
+ * @brief Collects whichever cross-backend memory usage stats are available
+ *
+ * Unlike gr_get_debug_stats(), this is always populated (no -gr_debug gate) -- memory usage is
+ * meant to be visible whenever the profiler overlay is open. Safe to call every frame regardless
+ * of backend or build configuration; groups a backend/build doesn't support stay invalid/zero.
+ */
+gr_memory_stats gr_get_memory_stats();
+
 inline void gr_setup_frame() {
 	gr_screen.gf_setup_frame();
 }
@@ -1318,6 +1405,16 @@ inline void gr_post_process_restore_zbuffer()
  */
 void gr_imgui_begin_frame();
 
+/**
+ * @brief Renders and submits the open ImGui frame, if any. Called by gr_flip().
+ */
+void gr_imgui_end_frame();
+
+/**
+ * @brief Whether an ImGui frame is currently open for contributions
+ */
+bool gr_imgui_frame_active();
+
 inline void gr_render_primitives(material* material_info,
 	primitive_type prim_type,
 	vertex_layout* layout,
@@ -1411,6 +1508,12 @@ inline bool gr_get_property(gr_property property, void* destination)
 	return gr_screen.gf_get_property(property, destination);
 }
 
+// Anisotropic filtering levels the current hardware supports: 1.0 (off), then powers of two up to
+// the reported maximum. Empty if anisotropy is unavailable or the hardware caps out below 4x, in
+// which case there is nothing meaningful to offer. Backs both the in-game option's enumerator and
+// qtFRED's Preferences combo, so the two can't drift.
+SCP_vector<float> gr_get_supported_anisotropy_levels();
+
 inline void gr_push_debug_group(const char* name)
 {
 	gr_screen.gf_push_debug_group(name);

code/graphics/opengl/gropengl.cpp

@@ -1126,6 +1126,7 @@ void gr_opengl_init_function_pointers()
 	gr_screen.gf_scene_texture_begin = gr_opengl_scene_texture_begin;
 	gr_screen.gf_scene_texture_end = gr_opengl_scene_texture_end;
 	gr_screen.gf_copy_effect_texture = gr_opengl_copy_effect_texture;
+	gr_screen.gf_resize_render_targets = gr_opengl_resize_render_targets;
 
 	gr_screen.gf_deferred_lighting_begin = gr_opengl_deferred_lighting_begin;
 	gr_screen.gf_deferred_lighting_msaa = gr_opengl_deferred_lighting_msaa;
@@ -1164,6 +1165,7 @@ void gr_opengl_init_function_pointers()
 
 	gr_screen.gf_is_capable = gr_opengl_is_capable;
 	gr_screen.gf_get_property = gr_opengl_get_property;
+	gr_screen.gf_get_memory_stats = gr_opengl_get_memory_stats;
 
 	gr_screen.gf_push_debug_group = gr_opengl_push_debug_group;
 	gr_screen.gf_pop_debug_group = gr_opengl_pop_debug_group;
@@ -1515,7 +1517,7 @@ bool gr_opengl_init(std::unique_ptr<os::GraphicsOperations>&& graphicsOps)
 	opengl_shader_init();
 
 	// post processing effects, after shaders are initialized
-	opengl_setup_scene_textures();
+	opengl_setup_scene_textures(gr_screen.max_w, gr_screen.max_h);
 	opengl_post_process_init();
 
 	// must be called after extensions are setup
@@ -1630,6 +1632,18 @@ bool gr_opengl_is_capable(gr_capability capability)
 	case gr_capability::CAPABILITY_RAYTRACED_SHADOWS:
 		// Raytraced shadows are only implemented for the Vulkan backend.
 		return false;
+	case gr_capability::CAPABILITY_SHADOW_CONTACT_HARDENING:
+		// Needs a second sampler object (compare mode off) on the shadow map. Sampler
+		// objects are technically also available pre-3.3 via ARB_sampler_objects, but this
+		// project's glad build only wires glGenSamplers/glBindSampler/glSamplerParameteri
+		// up behind the core GL_VERSION_3_3 flag, not a separate ARB entry point -- so that's
+		// the check that actually reflects whether those functions are non-null here.
+#ifdef USE_OPENGL_ES
+		// GLES has no GLAD_GL_VERSION_3_3 symbol, and the sampler setup here is desktop GL only.
+		return false;
+#else
+		return GLAD_GL_VERSION_3_3 != 0;
+#endif
 	}
 
 

code/graphics/opengl/gropengldeferred.cpp

@@ -86,7 +86,7 @@ void gr_opengl_deferred_lighting_begin(bool clearNonColorBufs)
 		Current_shader->program->Uniforms.setTextureUniform("tex", 0);
 		GL_state.SetAlphaBlendMode(gr_alpha_blend::ALPHA_BLEND_NONE);
 		GL_state.SetZbufferType(ZBUFFER_TYPE_NONE);
-		opengl_draw_full_screen_textured(0, 0, 1, 1);
+		opengl_draw_full_screen_scene_texture();
 	} else {
 		// Copy the existing color data into the emissive part of the G-buffer since everything that already existed is
 		// treated as emissive
@@ -159,7 +159,9 @@ void gr_opengl_deferred_lighting_msaa()
 		});
 	GL_state.SetAlphaBlendMode(gr_alpha_blend::ALPHA_BLEND_NONE);
 	GL_state.SetZbufferType(ZBUFFER_TYPE_WRITE);
-	opengl_draw_full_screen_textured(0, 0, 1, 1);
+	// msaa-f.sdr resolves via ivec2(textureSize(texColor) * fragTexCoord), so the texcoords have to
+	// stay inside the rendered sub-rectangle of the multisampled G-buffer.
+	opengl_draw_full_screen_scene_texture();
 }
 
 void gr_opengl_deferred_lighting_end()
@@ -174,6 +176,11 @@ void gr_opengl_deferred_lighting_end()
 	glDrawBuffer(GL_COLOR_ATTACHMENT0);
 
 	GL_state.ColorMask(true, true, true, false);
+
+	// Do not leave the raw-depth sampler bound after the pass.
+	if (Shadow_map_raw_sampler) {
+		GL_state.Texture.BindSampler(11, 0);
+	}
 }
 
 static GLuint deferred_light_cylinder_vbo = 0;
@@ -253,6 +260,10 @@ void gr_opengl_deferred_lighting_finish()
 	GL_state.Texture.Enable(3, GL_TEXTURE_2D, Scene_specular_texture);
 	if (Shadow_quality != ShadowQuality::Disabled) {
 		GL_state.Texture.Enable(4, GL_TEXTURE_2D_ARRAY, Shadow_map_depth_texture);
+		if (Shadow_map_raw_sampler) {
+			GL_state.Texture.Enable(11, GL_TEXTURE_2D_ARRAY, Shadow_map_depth_texture);
+			GL_state.Texture.BindSampler(11, Shadow_map_raw_sampler);
+		}
 	}
 
 	if (ENVMAP > 0) {
@@ -319,8 +330,12 @@ void gr_opengl_deferred_lighting_finish()
 			shadow_cascade_params_bind_deferred();
 		}
 
-		header->invScreenWidth = 1.0f / gr_screen.max_w;
-		header->invScreenHeight = 1.0f / gr_screen.max_h;
+		// deferred-f.sdr turns gl_FragCoord into a G-buffer texture coordinate with these, so they
+		// have to normalize against the G-buffer's own dimensions. Those only equal gr_screen while
+		// the viewport exactly fills the scene textures -- not after a shrink, and not when the
+		// allocation was clamped by GL_max_renderbuffer_size.
+		header->invScreenWidth = 1.0f / Scene_texture_width;
+		header->invScreenHeight = 1.0f / Scene_texture_height;
 		header->nearPlane = gr_near_plane;
 
 		{
@@ -555,7 +570,8 @@ void gr_opengl_deferred_lighting_finish()
 			data->clip_dist       = Neb2_fog_clip_distance;
 		});
 
-		opengl_draw_full_screen_textured(0.0f, 0.0f, 1.0f, 1.0f);
+		// fog-f.sdr samples the composite and depth targets straight off fragTexCoord.
+		opengl_draw_full_screen_scene_texture();
 
 		if (bDrawNebVolumetrics) {
 			glReadBuffer(GL_COLOR_ATTACHMENT0);
@@ -651,6 +667,12 @@ void gr_opengl_deferred_lighting_finish()
 
 		{
 			GR_DEBUG_SCOPE("Volumetric Nebulae Draw");
+			// Deliberately unscaled. volumetric-f.sdr uses fragTexCoord for two incompatible
+			// things: reconstructing an eye-space ray direction, which needs the full 0..1 range
+			// across the viewport, and sampling composite/depth/emissive, which needs the
+			// rendered sub-rectangle. Scaling here would fix the sampling and skew every ray.
+			// Separating the two needs a second varying (or a scale uniform) in the shader; until
+			// then volumetrics are only correct while the targets exactly match the viewport.
 			opengl_draw_full_screen_textured(0.0f, 0.0f, 1.0f, 1.0f);
 		}
 		GL_state.Texture.Enable(Scene_emissive_texture);

code/graphics/opengl/gropengldraw.cpp

@@ -70,6 +70,33 @@ int Scene_texture_height;
 GLfloat Scene_texture_u_scale = 1.0f;
 GLfloat Scene_texture_v_scale = 1.0f;
 
+// Render targets are torn down and rebuilt mid-session by gr_opengl_resize_render_targets(), not
+// just at shutdown, so deletion has to go through the state cache: the driver is free to hand a
+// freed name straight back out, and a cache entry still holding that name would make a later
+// Enable() of the recycled texture a no-op.
+void opengl_delete_render_texture(GLuint& tex)
+{
+	if ( !tex ) {
+		return;
+	}
+
+	GL_state.Texture.Delete(tex);
+	glDeleteTextures(1, &tex);
+	tex = 0;
+}
+
+// Callers must have bound something else first (the resize path binds 0); the framebuffer cache
+// has no equivalent of Texture.Delete() to unbind through.
+void opengl_delete_render_framebuffer(GLuint& fbo)
+{
+	if ( !fbo ) {
+		return;
+	}
+
+	glDeleteFramebuffers(1, &fbo);
+	fbo = 0;
+}
+
 inline GLenum opengl_primitive_type(primitive_type prim_type)
 {
 	switch ( prim_type ) {
@@ -98,7 +125,7 @@ void gr_opengl_sphere(material* material_def, float  /*rad*/)
 }
 
 extern int opengl_check_framebuffer();
-void opengl_setup_scene_textures()
+void opengl_setup_scene_textures(int width, int height)
 {
 	Scene_texture_initialized = 0;
 
@@ -113,10 +140,10 @@ void opengl_setup_scene_textures()
 		return;
 	}
 
-	// clamp size, if needed
-	Scene_texture_width = gr_screen.max_w;
-	Scene_texture_height = gr_screen.max_h;
+	Scene_texture_width = width;
+	Scene_texture_height = height;
 
+	// clamp size, if needed
 	if ( Scene_texture_width > GL_max_renderbuffer_size ) {
 		Scene_texture_width = GL_max_renderbuffer_size;
 	}
@@ -125,6 +152,13 @@ void opengl_setup_scene_textures()
 		Scene_texture_height = GL_max_renderbuffer_size;
 	}
 
+	mprintf(("  Scene textures: %dx%d (screen %dx%d, max renderbuffer %d)\n",
+		Scene_texture_width,
+		Scene_texture_height,
+		gr_screen.max_w,
+		gr_screen.max_h,
+		GL_max_renderbuffer_size));
+
 	// create framebuffer
 	glGenFramebuffers(1, &Scene_framebuffer);
 	GL_state.BindFrameBuffer(Scene_framebuffer);
@@ -333,32 +367,15 @@ void opengl_setup_scene_textures()
 
 	if ( opengl_check_framebuffer() ) {
 		GL_state.BindFrameBuffer(0);
-		glDeleteFramebuffers(1, &Scene_framebuffer);
-		Scene_framebuffer = 0;
+		opengl_delete_render_framebuffer(Scene_framebuffer);
 
-		glDeleteTextures(1, &Scene_color_texture);
-		Scene_color_texture = 0;
-
-		glDeleteTextures(1, &Scene_position_texture);
-		Scene_position_texture = 0;
-
-		glDeleteTextures(1, &Scene_normal_texture);
-		Scene_normal_texture = 0;
-
-		glDeleteTextures(1, &Scene_specular_texture);
-		Scene_specular_texture = 0;
-
-		glDeleteTextures(1, &Scene_emissive_texture);
-		Scene_emissive_texture = 0;
-
-		glDeleteTextures(1, &Scene_depth_texture);
-		Scene_depth_texture = 0;
-
-		glDeleteTextures(1, &Scene_luminance_texture);
-		Scene_luminance_texture = 0;
-
-		//glDeleteTextures(1, &Scene_fxaa_output_texture);
-		//Scene_fxaa_output_texture = 0;
+		opengl_delete_render_texture(Scene_color_texture);
+		opengl_delete_render_texture(Scene_position_texture);
+		opengl_delete_render_texture(Scene_normal_texture);
+		opengl_delete_render_texture(Scene_specular_texture);
+		opengl_delete_render_texture(Scene_emissive_texture);
+		opengl_delete_render_texture(Scene_depth_texture);
+		opengl_delete_render_texture(Scene_luminance_texture);
 
 		Gr_post_processing_enabled = false;
 		Gr_enable_soft_particles = false;
@@ -687,79 +704,165 @@ void opengl_scene_texture_shutdown()
 		return;
 	}
 
-	if ( Scene_color_texture ) {
-		glDeleteTextures(1, &Scene_color_texture);
-		Scene_color_texture = 0;
-	}
+	// Everything opengl_setup_scene_textures() generated, in the same order. Note that
+	// GammaBlit_texture is 0 when the gamma pass is aliasing Scene_ldr_texture, so the shared
+	// texture is only released once.
+	opengl_delete_render_texture(Scene_color_texture);
+	opengl_delete_render_texture(Scene_ldr_texture);
+	opengl_delete_render_texture(Scene_position_texture);
+	opengl_delete_render_texture(Scene_normal_texture);
+	opengl_delete_render_texture(Scene_specular_texture);
+	opengl_delete_render_texture(Scene_emissive_texture);
+	opengl_delete_render_texture(Scene_composite_texture);
+	opengl_delete_render_texture(Scene_luminance_texture);
+	opengl_delete_render_texture(Cockpit_depth_texture);
+	opengl_delete_render_texture(Scene_depth_texture);
+	opengl_delete_render_framebuffer(Scene_framebuffer);
 
-	if ( Scene_position_texture ) {
-		glDeleteTextures(1, &Scene_position_texture);
-		Scene_position_texture = 0;
-	}
+	opengl_delete_render_texture(Scene_color_texture_ms);
+	opengl_delete_render_texture(Scene_position_texture_ms);
+	opengl_delete_render_texture(Scene_normal_texture_ms);
+	opengl_delete_render_texture(Scene_specular_texture_ms);
+	opengl_delete_render_texture(Scene_emissive_texture_ms);
+	opengl_delete_render_texture(Scene_depth_texture_ms);
+	opengl_delete_render_framebuffer(Scene_framebuffer_ms);
 
-	if ( Scene_normal_texture ) {
-		glDeleteTextures(1, &Scene_normal_texture);
-		Scene_normal_texture = 0;
-	}
+	opengl_delete_render_texture(Back_texture);
+	opengl_delete_render_texture(Back_depth_texture);
+	opengl_delete_render_framebuffer(Back_framebuffer);
 
-	if ( Scene_specular_texture ) {
-		glDeleteTextures(1, &Scene_specular_texture);
-		Scene_specular_texture = 0;
-	}
+	opengl_delete_render_texture(GammaBlit_texture);
+	opengl_delete_render_framebuffer(GammaBlit_framebuffer);
 
-	if (Scene_emissive_texture) {
-		glDeleteTextures(1, &Scene_emissive_texture);
-		Scene_emissive_texture = 0;
-	}
-
-	if ( Scene_depth_texture ) {
-		glDeleteTextures(1, &Scene_depth_texture);
-		Scene_depth_texture = 0;
-	}
-
-	if ( Scene_framebuffer ) {
-		glDeleteFramebuffers(1, &Scene_framebuffer);
-		Scene_framebuffer = 0;
-	}
-
-	if (Back_texture) {
-		glDeleteTextures(1, &Back_texture);
-		Back_texture = 0;
-	}
-
-	if (Back_depth_texture) {
-		glDeleteTextures(1, &Back_depth_texture);
-		Back_depth_texture = 0;
-	}
-
-	if (Back_framebuffer) {
-		glDeleteFramebuffers(1, &Back_framebuffer);
-		Back_framebuffer = 0;
-	}
-
-	if (GammaBlit_texture) {
-		glDeleteTextures(1, &GammaBlit_texture);
-		GammaBlit_texture = 0;
-	}
-
-	if (GammaBlit_framebuffer) {
-		glDeleteFramebuffers(1, &GammaBlit_framebuffer);
-		GammaBlit_framebuffer = 0;
-	}
-
-	glDeleteTextures(2, Distortion_texture);
-	Distortion_texture[0] = 0;
-	Distortion_texture[1] = 0;
-
-	if ( Distortion_framebuffer ) {
-		glDeleteFramebuffers(1, &Distortion_framebuffer);
-		Distortion_framebuffer = 0;
-	}
+	opengl_delete_render_texture(Distortion_texture[0]);
+	opengl_delete_render_texture(Distortion_texture[1]);
+	opengl_delete_render_framebuffer(Distortion_framebuffer);
 
 	Scene_texture_initialized = 0;
 	Scene_framebuffer_in_frame = false;
 }
 
+void gr_opengl_resize_render_targets()
+{
+	// Nothing allocated yet (still inside gr_init()), or FBOs are unavailable entirely.
+	if ( !Scene_texture_initialized ) {
+		return;
+	}
+
+	// Grow only. Shrinking back would mean reallocating every G-buffer again the moment the window
+	// grew back, and the shrunk state is already handled correctly: Scene_texture_u_scale and
+	// _v_scale confine rendering to the sub-rectangle actually in use. The hardware limit is
+	// applied here rather than left to opengl_setup_scene_textures(), so that a viewport larger
+	// than anything the GPU can allocate compares equal below and stops asking.
+	const int new_width = MIN(MAX(gr_screen.max_w, Scene_texture_width), GL_max_renderbuffer_size);
+	const int new_height = MIN(MAX(gr_screen.max_h, Scene_texture_height), GL_max_renderbuffer_size);
+
+	// The overwhelmingly common case: qtFred calls gr_screen_resize() every frame and the game
+	// calls it on every SDL resize event, almost always at a size the current targets already
+	// cover -- or, past the hardware limit, at one they never will.
+	if ( new_width == Scene_texture_width && new_height == Scene_texture_height ) {
+		return;
+	}
+
+	// Tearing down the framebuffer we are currently rendering into would corrupt the frame rather
+	// than fail cleanly, so refuse rather than trying to recover. Callers resize between frames.
+	// Scene_framebuffer_in_frame covers the post-processing passes too: they only ever run inside
+	// gr_scene_texture_begin()/end(), so it is set for the whole of Post_in_frame as well.
+	if ( Scene_framebuffer_in_frame ) {
+		Assertion(false, "Tried to resize the render targets to %dx%d while a scene was being "
+			"rendered into them! The resize has been skipped; the frame will be stretched.",
+			new_width, new_height);
+		return;
+	}
+
+	mprintf(("Growing render targets from %dx%d to %dx%d to cover the new %dx%d viewport.\n",
+		Scene_texture_width, Scene_texture_height, new_width, new_height,
+		gr_screen.max_w, gr_screen.max_h));
+
+	// Leave the framebuffer cache pointing at a name that cannot be deleted out from under it.
+	GL_state.BindFrameBufferBoth(0, 0);
+
+	// Only the size-dependent resources are touched. The post-processing table, the compiled
+	// shaders and the SMAA lookup textures are all resolution-independent and stay alive, which is
+	// what keeps this cheap enough to run off a window drag. The post-processing targets are
+	// rebuilt after the scene textures because they are sized to match them.
+	opengl_scene_texture_shutdown();
+	opengl_setup_scene_textures(new_width, new_height);
+
+	// Reallocating larger is exactly when running out of video memory is most likely, and
+	// opengl_setup_scene_textures() reports that by leaving the scene uninitialized (having
+	// already turned post-processing and soft particles off). Rebuilding the post-processing
+	// targets on top of scene textures that don't exist would only make it worse, so stop here;
+	// the renderer keeps drawing without the offscreen pipeline.
+	if ( !Scene_texture_initialized ) {
+		mprintf(("Failed to allocate %dx%d render targets! The offscreen rendering pipeline has "
+			"been disabled for the rest of this session.\n", new_width, new_height));
+		return;
+	}
+
+	opengl_post_resize_render_targets();
+}
+
+size_t opengl_get_scene_render_target_bytes()
+{
+	// The bytes for each pixel come from the internal formats that opengl_setup_scene_textures()
+	// gives to these textures: GL_RGBA16F holds 8 bytes, GL_RGBA8 and GL_DEPTH24_STENCIL8 hold 4.
+	// Keep the values below equal to the formats at the creation sites in that function.
+	constexpr size_t RGBA16F_BYTES = 8;
+	constexpr size_t RGBA8_BYTES = 4;
+	constexpr size_t DEPTH24_STENCIL8_BYTES = 4;
+
+	size_t bytes = 0;
+
+	auto add_texture = [&bytes](GLuint texture_id, size_t width, size_t height, size_t bytes_per_pixel,
+							 size_t samples = 1) {
+		if (texture_id == 0) {
+			return;
+		}
+		bytes += width * height * bytes_per_pixel * samples;
+	};
+
+	const auto scene_w = static_cast<size_t>(Scene_texture_width);
+	const auto scene_h = static_cast<size_t>(Scene_texture_height);
+
+	add_texture(Scene_color_texture, scene_w, scene_h, RGBA16F_BYTES);
+	add_texture(Scene_ldr_texture, scene_w, scene_h, RGBA8_BYTES);
+	add_texture(Scene_position_texture, scene_w, scene_h, RGBA16F_BYTES);
+	add_texture(Scene_normal_texture, scene_w, scene_h, RGBA16F_BYTES);
+	add_texture(Scene_specular_texture, scene_w, scene_h, RGBA8_BYTES);
+	add_texture(Scene_emissive_texture, scene_w, scene_h, RGBA16F_BYTES);
+	add_texture(Scene_composite_texture, scene_w, scene_h, RGBA16F_BYTES);
+	add_texture(Scene_luminance_texture, scene_w, scene_h, RGBA16F_BYTES);
+	add_texture(Cockpit_depth_texture, scene_w, scene_h, DEPTH24_STENCIL8_BYTES);
+	add_texture(Scene_depth_texture, scene_w, scene_h, DEPTH24_STENCIL8_BYTES);
+
+	// The multisample textures hold one value for each sample, thus their bytes go up with the
+	// MSAA level. Cmdline_msaa_enabled holds the number of samples and is 0 when MSAA is off.
+	const auto samples = static_cast<size_t>(std::max(1, Cmdline_msaa_enabled));
+
+	add_texture(Scene_color_texture_ms, scene_w, scene_h, RGBA16F_BYTES, samples);
+	add_texture(Scene_position_texture_ms, scene_w, scene_h, RGBA16F_BYTES, samples);
+	add_texture(Scene_normal_texture_ms, scene_w, scene_h, RGBA16F_BYTES, samples);
+	add_texture(Scene_specular_texture_ms, scene_w, scene_h, RGBA8_BYTES, samples);
+	add_texture(Scene_emissive_texture_ms, scene_w, scene_h, RGBA16F_BYTES, samples);
+	add_texture(Scene_depth_texture_ms, scene_w, scene_h, DEPTH24_STENCIL8_BYTES, samples);
+
+	// The back buffer and gamma blit textures use the size of the screen, not the (clamped) size
+	// of the scene textures.
+	const auto screen_w = static_cast<size_t>(gr_screen.max_w);
+	const auto screen_h = static_cast<size_t>(gr_screen.max_h);
+
+	add_texture(Back_texture, screen_w, screen_h, RGBA16F_BYTES);
+	add_texture(Back_depth_texture, screen_w, screen_h, DEPTH24_STENCIL8_BYTES);
+	add_texture(GammaBlit_texture, screen_w, screen_h, RGBA8_BYTES);
+
+	// The two distortion textures always have the size 32x32.
+	add_texture(Distortion_texture[0], 32, 32, RGBA8_BYTES);
+	add_texture(Distortion_texture[1], 32, 32, RGBA8_BYTES);
+
+	return bytes;
+}
+
 void gr_opengl_scene_texture_begin()
 {
 	if ( !Scene_texture_initialized ) {
@@ -800,6 +903,30 @@ void gr_opengl_scene_texture_begin()
 		Scene_texture_v_scale = 1.0f;
 	}
 
+	// A ratio above 1.0 means the viewport outgrew the allocation after the fact -- the scene
+	// texture can't be resized, so all we can do is render the part that fits and let the blit
+	// stretch it back out, which misaligns everything by a different amount on each axis. The
+	// floor above is meant to make this unreachable; if it does happen (a display hotplug or
+	// resolution change after gr_init(), or an allocation clamped by GL_max_renderbuffer_size on
+	// low-end hardware) say so once rather than every frame.
+	if (Scene_texture_u_scale > 1.0f || Scene_texture_v_scale > 1.0f) {
+		static bool reported_undersized_scene_texture = false;
+
+		if (!reported_undersized_scene_texture) {
+			reported_undersized_scene_texture = true;
+			nprintf(("OpenGL",
+				"Viewport (%dx%d) is larger than the scene texture backing it (%dx%d); "
+				"the post-processed image will be stretched to fit.\n",
+				gr_screen.max_w,
+				gr_screen.max_h,
+				Scene_texture_width,
+				Scene_texture_height));
+		}
+	}
+
+	CLAMP(Scene_texture_u_scale, 0.0f, 1.0f);
+	CLAMP(Scene_texture_v_scale, 0.0f, 1.0f);
+
 	if (!light_deferred_enabled()) {
 		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -1246,6 +1373,11 @@ void opengl_draw_full_screen_textured(GLfloat u1, GLfloat v1, GLfloat u2, GLfloa
 	opengl_render_primitives_immediate(PRIM_TYPE_TRIS, &vert_def, 3, glVertices, sizeof(glVertices));
 }
 
+void opengl_draw_full_screen_scene_texture()
+{
+	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_v_scale);
+}
+
 void gr_opengl_render_decals(decal_material* material_info,
 							 primitive_type prim_type,
 							 vertex_layout* layout,

code/graphics/opengl/gropengldraw.h

@@ -55,8 +55,23 @@ void gr_opengl_render_shield_impact(shield_material* material_info,
 	gr_buffer_handle buffer_handle,
 	int n_verts);
 
-void opengl_setup_scene_textures();
+void opengl_setup_scene_textures(int width, int height);
 void opengl_scene_texture_shutdown();
+void gr_opengl_resize_render_targets();
+
+// Release a render target, keeping the GL state cache in sync. See the definitions for why the
+// cache matters now that these are rebuilt mid-session.
+void opengl_delete_render_texture(GLuint& tex);
+void opengl_delete_render_framebuffer(GLuint& fbo);
+
+/**
+ * @brief Gives the bytes that the scene, backbuffer, and distortion textures hold
+ *
+ * The profiler overlay's memory panel adds this value to the "render targets" group. The function
+ * counts only the textures that exist at the moment of the call, thus it gives 0 before
+ * opengl_setup_scene_textures() runs and after opengl_scene_texture_shutdown() runs.
+ */
+size_t opengl_get_scene_render_target_bytes();
 void gr_opengl_scene_texture_begin();
 void gr_opengl_scene_texture_end();
 void gr_opengl_copy_effect_texture();
@@ -147,6 +162,12 @@ void opengl_draw_textured_quad(GLfloat x1,
  */
 void opengl_draw_full_screen_textured(GLfloat u1, GLfloat v1, GLfloat u2, GLfloat v2);
 
+// Fullscreen pass over a source that is one of the scene/post-processing textures. Those are only
+// filled out to Scene_texture_u_scale/v_scale of their allocation, so sampling them over the full
+// [0,1] range would pull in whatever is beyond the rendered region. Prefer this over passing
+// literal 1.0f extents whenever the bound texture came from that pipeline.
+void opengl_draw_full_screen_scene_texture();
+
 inline GLenum opengl_primitive_type(primitive_type prim_type);
 
 void gr_opengl_start_decal_pass();

code/graphics/opengl/gropenglpostprocessing.cpp

@@ -28,6 +28,9 @@
 #include "es_compatibility.h"
 #endif
 
+static void opengl_post_setup_render_targets();
+static void opengl_post_shutdown_render_targets();
+
 extern bool PostProcessing_override;
 extern int opengl_check_framebuffer();
 // Needed to track where the FXAA shaders are
@@ -99,7 +102,7 @@ void opengl_post_pass_tonemap()
 
 	GL_state.Texture.Enable(0, GL_TEXTURE_2D, Scene_color_texture);
 
-	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+	opengl_draw_full_screen_scene_texture();
 }
 
 void opengl_post_pass_bloom()
@@ -134,7 +137,10 @@ void opengl_post_pass_bloom()
 
 		GL_state.Texture.Enable(0, GL_TEXTURE_2D, Scene_color_texture);
 
-		opengl_draw_full_screen_textured(0.0f, 0.0f, 1.0f, 1.0f);
+		// Reads the scene texture directly rather than an already-cropped intermediate, so it is
+		// the scaled variant. The blur/composite passes below read Bloom_textures, which this pass
+		// fills edge to edge, so those stay unscaled.
+		opengl_draw_full_screen_scene_texture();
 	}
 	// ------ end bright pass ------
 
@@ -293,7 +299,7 @@ void opengl_post_pass_fxaa()
 
 	GL_state.Texture.Enable(0, GL_TEXTURE_2D, Scene_ldr_texture);
 
-	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+	opengl_draw_full_screen_scene_texture();
 
 	// set and configure post shader ..
 	opengl_shader_set_current(gr_opengl_maybe_create_shader(SDR_TYPE_POST_PROCESS_FXAA, 0));
@@ -310,7 +316,7 @@ void opengl_post_pass_fxaa()
 
 	GL_state.Texture.Enable(0, GL_TEXTURE_2D, Scene_luminance_texture);
 
-	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+	opengl_draw_full_screen_scene_texture();
 
 	opengl_shader_set_current();
 }
@@ -333,7 +339,7 @@ static void smaa_detect_edges()
 
 	GL_state.Texture.Enable(0, GL_TEXTURE_2D, Scene_ldr_texture);
 
-	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+	opengl_draw_full_screen_scene_texture();
 }
 
 static void smaa_calculate_blending_weights()
@@ -358,7 +364,7 @@ static void smaa_calculate_blending_weights()
 	GL_state.Texture.Enable(1, GL_TEXTURE_2D, Smaa_area_tex);
 	GL_state.Texture.Enable(2, GL_TEXTURE_2D, Smaa_search_tex);
 
-	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+	opengl_draw_full_screen_scene_texture();
 }
 
 static void smaa_neighborhood_blending()
@@ -381,7 +387,7 @@ static void smaa_neighborhood_blending()
 	GL_state.Texture.Enable(0, GL_TEXTURE_2D, Scene_ldr_texture);
 	GL_state.Texture.Enable(1, GL_TEXTURE_2D, Smaa_blend_tex);
 
-	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+	opengl_draw_full_screen_scene_texture();
 }
 
 void smaa_resolve()
@@ -491,7 +497,7 @@ void opengl_post_lightshafts()
 				GL_state.Blend(GL_TRUE);
 				GL_state.SetAlphaBlendMode(ALPHA_BLEND_ADDITIVE);
 
-				opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+				opengl_draw_full_screen_scene_texture();
 
 				GL_state.Blend(GL_FALSE);
 				break;
@@ -625,7 +631,7 @@ void gr_opengl_post_process_end()
 	// now render it to the screen ...
 	GL_state.PopFramebufferState();
 
-	opengl_draw_full_screen_textured(0.0f, 0.0f, Scene_texture_u_scale, Scene_texture_u_scale);
+	opengl_draw_full_screen_scene_texture();
 
 	//Shadow Map debug window
 //#define SHADOW_DEBUG
@@ -1020,77 +1026,140 @@ static GLuint load_smaa_texture(GLsizei width, GLsizei height, GLenum format, co
 	return tex;
 }
 
-static void setup_smaa_resources()
+// The SMAA area and search textures are fixed-size lookup tables baked into the binary, so unlike
+// everything else here they survive a resolution change untouched.
+static void setup_smaa_lookup_textures()
 {
-	GL_state.PushFramebufferState();
-
 	Smaa_area_tex = load_smaa_texture(AREATEX_WIDTH, AREATEX_HEIGHT, GL_RG8, areaTexBytes, "SMAA Area Texture");
 	Smaa_search_tex =
 	    load_smaa_texture(SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, GL_R8, searchTexBytes, "SMAA Search Texture");
+}
 
+static void setup_smaa_render_targets()
+{
 	setup_smaa_edges_resources();
 
 	setup_smaa_blending_weight_resources();
 
 	setup_smaa_neighborhood_blending_resources();
-
-	GL_state.PopFramebufferState();
 }
 
-// generate and test the framebuffer and textures that we are going to use
-static bool opengl_post_init_framebuffer()
+static void shutdown_smaa_render_targets()
 {
-	bool rval = false;
+	opengl_delete_render_texture(Smaa_edges_tex);
+	opengl_delete_render_framebuffer(Smaa_edge_detection_fb);
 
-	// clamp size, if needed
-	Post_texture_width = gr_screen.max_w;
-	Post_texture_height = gr_screen.max_h;
+	opengl_delete_render_texture(Smaa_blend_tex);
+	opengl_delete_render_framebuffer(Smaa_blending_weight_fb);
 
-	if (Post_texture_width > GL_max_renderbuffer_size) {
-		Post_texture_width = GL_max_renderbuffer_size;
-	}
+	opengl_delete_render_texture(Smaa_output_tex);
+	opengl_delete_render_framebuffer(Smaa_neighborhood_blending_fb);
+}
 
-	if (Post_texture_height > GL_max_renderbuffer_size) {
-		Post_texture_height = GL_max_renderbuffer_size;
-	}
+// Allocate every post-processing resource whose size follows the scene textures. Split out from
+// opengl_post_process_init() so gr_opengl_resize_render_targets() can rebuild just these without
+// re-parsing post_processing.tbl or recompiling shaders.
+static void opengl_post_setup_render_targets()
+{
+	// These consume the scene textures pass by pass, so they have to match them exactly rather
+	// than being sized from gr_screen independently -- see gr_opengl_scene_texture_begin() for
+	// what the two sizes diverging would mean.
+	Post_texture_width = Scene_texture_width;
+	Post_texture_height = Scene_texture_height;
+
+	GL_state.PushFramebufferState();
 
 	opengl_setup_bloom_textures();
 
 	// Always set up SMAA resources so the user can switch to an SMAA preset
 	// at runtime even when starting with a non-SMAA AA mode, such as None.
-	//if (Gr_aa_mode != AntiAliasMode::None) {
-		setup_smaa_resources();
-	//}
+	setup_smaa_render_targets();
+
+	GL_state.PopFramebufferState();
 
 	GL_state.BindFrameBuffer(0);
-
-	rval = true;
-
-	if ( opengl_check_for_errors("post_init_framebuffer()") ) {
-		rval = false;
-	}
-
-	return rval;
 }
 
-
-
 void opengl_post_process_shutdown_bloom()
 {
-	if ( Bloom_textures[0] ) {
-		glDeleteTextures(1, &Bloom_textures[0]);
-		Bloom_textures[0] = 0;
+	opengl_delete_render_texture(Bloom_textures[0]);
+	opengl_delete_render_texture(Bloom_textures[1]);
+	opengl_delete_render_framebuffer(Bloom_framebuffer);
+}
+
+static void opengl_post_shutdown_render_targets()
+{
+	opengl_post_process_shutdown_bloom();
+	shutdown_smaa_render_targets();
+}
+
+void opengl_post_resize_render_targets()
+{
+	// Post-processing may have been disabled outright (no FBOs, missing shaders, or turned off in
+	// the table), in which case none of these resources exist and none should start existing now.
+	if ( !Post_initialized ) {
+		return;
 	}
 
-	if ( Bloom_textures[1] ) {
-		glDeleteTextures(1, &Bloom_textures[1]);
-		Bloom_textures[1] = 0;
+	opengl_post_shutdown_render_targets();
+	opengl_post_setup_render_targets();
+}
+
+// generate and test the framebuffer and textures that we are going to use
+static bool opengl_post_init_framebuffer()
+{
+	setup_smaa_lookup_textures();
+
+	opengl_post_setup_render_targets();
+
+	return !opengl_check_for_errors("post_init_framebuffer()");
+}
+
+size_t opengl_get_postprocessing_render_target_bytes()
+{
+	// The bytes for each pixel come from the internal formats at the creation sites in this file:
+	// GL_RGBA16F holds 8 bytes and GL_RGBA8 holds 4. Keep these values equal to those formats.
+	constexpr size_t RGBA16F_BYTES = 8;
+	constexpr size_t RGBA8_BYTES = 4;
+
+	size_t bytes = 0;
+
+	// The bloom textures are half the size of the post-processing textures. opengl_setup_bloom_textures()
+	// calls glGenerateMipmap() before it sets GL_TEXTURE_MAX_LEVEL, thus the driver holds the full
+	// mipmap chain, not only MAX_MIP_BLUR_LEVELS levels.
+	for (GLuint bloom_texture : Bloom_textures) {
+		if (bloom_texture == 0) {
+			continue;
+		}
+
+		auto width = static_cast<size_t>(std::max(1, Post_texture_width >> 1));
+		auto height = static_cast<size_t>(std::max(1, Post_texture_height >> 1));
+		while (true) {
+			bytes += width * height * RGBA16F_BYTES;
+			if ((width == 1) && (height == 1)) {
+				break;
+			}
+			width = std::max<size_t>(1, width >> 1);
+			height = std::max<size_t>(1, height >> 1);
+		}
 	}
 
-	if ( Bloom_framebuffer > 0 ) {
-		glDeleteFramebuffers(1, &Bloom_framebuffer);
-		Bloom_framebuffer = 0;
+	// The SMAA area and search textures stay out of this total. They hold lookup data of a fixed
+	// small size, thus they are not render targets.
+	const auto post_w = static_cast<size_t>(Post_texture_width);
+	const auto post_h = static_cast<size_t>(Post_texture_height);
+
+	if (Smaa_edges_tex != 0) {
+		bytes += post_w * post_h * RGBA8_BYTES;
 	}
+	if (Smaa_blend_tex != 0) {
+		bytes += post_w * post_h * RGBA8_BYTES;
+	}
+	if (Smaa_output_tex != 0) {
+		bytes += post_w * post_h * RGBA8_BYTES;
+	}
+
+	return bytes;
 }
 
 void opengl_post_process_init()
@@ -1141,20 +1210,16 @@ void opengl_post_process_shutdown()
 		return;
 	}
 
-	if (Post_framebuffer_id[0]) {
-		glDeleteFramebuffers(1, &Post_framebuffer_id[0]);
-		Post_framebuffer_id[0] = 0;
-
-		if (Post_framebuffer_id[1]) {
-			glDeleteFramebuffers(1, &Post_framebuffer_id[1]);
-			Post_framebuffer_id[1] = 0;
-		}
-	}
+	opengl_delete_render_framebuffer(Post_framebuffer_id[0]);
+	opengl_delete_render_framebuffer(Post_framebuffer_id[1]);
 
 	graphics::Post_processing_manager->clear();
 	graphics::Post_processing_manager = nullptr;
 
-	opengl_post_process_shutdown_bloom();
+	opengl_post_shutdown_render_targets();
+
+	opengl_delete_render_texture(Smaa_area_tex);
+	opengl_delete_render_texture(Smaa_search_tex);
 
 	Post_in_frame = false;
 	Post_active_shader_index = 0;

code/graphics/opengl/gropenglpostprocessing.h

@@ -8,6 +8,18 @@
 void opengl_post_process_init();
 void opengl_post_process_shutdown();
 
+// Rebuild the resolution-dependent subset of the above for the current scene texture size, without
+// re-parsing post_processing.tbl or recompiling shaders. No-op if post-processing isn't active.
+void opengl_post_resize_render_targets();
+
+/**
+ * @brief Gives the bytes that the bloom and SMAA render textures hold
+ *
+ * The profiler overlay's memory panel adds this value to the "render targets" group. The function
+ * counts only the textures that exist at the moment of the call.
+ */
+size_t opengl_get_postprocessing_render_target_bytes();
+
 void gr_opengl_post_process_set_effect(const char *name, int x, const vec3d *rgb);
 void gr_opengl_post_process_set_defaults();
 void gr_opengl_post_process_save_zbuffer();

code/graphics/opengl/gropenglshader.cpp

@@ -433,6 +433,9 @@ static void opengl_set_default_uniforms(const opengl_shader_t& sdr) {
 		Current_shader->program->Uniforms.setTextureUniform("PositionBuffer", 2);
 		Current_shader->program->Uniforms.setTextureUniform("SpecBuffer", 3);
 		Current_shader->program->Uniforms.setTextureUniform("shadow_map", 4);
+		// Unit 11 matches the model pass. Unit 7 is the model misc map, so do not use it
+		// -- see the raw-sampler bind in gropengldeferred.cpp.
+		Current_shader->program->Uniforms.setTextureUniform("shadow_map_raw", 11);
 		break;
 
 	case SDR_TYPE_PASSTHROUGH_RENDER:

code/graphics/opengl/gropenglstate.cpp

@@ -37,6 +37,7 @@ void opengl_texture_state::init(GLuint n_units)
 
 	for (unsigned int unit = 0; unit < num_texture_units; unit++) {
 		units[unit].enabled = GL_FALSE;
+		units[unit].bound_sampler = 0;
 
 		default_values(unit);
 
@@ -113,6 +114,18 @@ void opengl_texture_state::Enable(GLuint unit, GLenum tex_target, GLuint tex_id)
 	Enable(tex_id);
 }
 
+void opengl_texture_state::BindSampler(GLuint unit, GLuint sampler)
+{
+	Assertion(unit < num_texture_units, "Invalid texture unit value!");
+
+	if (units[unit].bound_sampler == sampler) {
+		return;
+	}
+
+	glBindSampler(unit, sampler);
+	units[unit].bound_sampler = sampler;
+}
+
 void opengl_texture_state::Delete(GLuint tex_id)
 {
 	if (tex_id == 0) {

code/graphics/opengl/gropenglstate.h

@@ -27,6 +27,12 @@ struct opengl_texture_unit {
 
 	GLenum texture_target;
 	GLuint texture_id;
+
+	// Sampler object bound to this unit, overriding the texture object's own filter/compare
+	// state for as long as it stays bound (0 = none, texture-level state applies as usual).
+	// Tracked here for the same reason texture_id is: so BindSampler() can skip a redundant
+	// glBindSampler call, exactly like Enable() already does for glBindTexture.
+	GLuint bound_sampler;
 };
 
 class opengl_texture_state
@@ -65,7 +71,20 @@ class opengl_texture_state
 		 */
 		void Enable(GLuint unit, GLenum tex_target, GLuint tex_id);
 		void Delete(GLuint tex_id);
-		
+
+		/**
+		 * @brief Binds a sampler object to the specified unit, or unbinds one if sampler is 0
+		 *
+		 * Sampler objects override the bound texture's own filter/compare-mode state for
+		 * that unit only, which is otherwise impossible to vary per-unit in this codebase
+		 * (texture parameters like GL_TEXTURE_COMPARE_MODE live on the texture object, not
+		 * a sampler). No-ops if the unit already has this sampler bound, mirroring Enable().
+		 *
+		 * @param unit The texture unit to bind the sampler to
+		 * @param sampler The sampler object to bind, or 0 to unbind
+		 */
+		void BindSampler(GLuint unit, GLuint sampler);
+
 		inline GLenum GetTarget();
 		inline void SetShaderMode(GLboolean mode);
 };

code/graphics/opengl/gropengltexture.cpp

@@ -15,11 +15,14 @@
 #include "gropenglstate.h"
 #include "gropengltexture.h"
 #include "gropengldraw.h"
+#include "gropenglpostprocessing.h"
+#include "gropengltnl.h"
 #include "bmpman/bm_internal.h"
 #include "bmpman/bmpman.h"
 #include "cmdline/cmdline.h"
 #include "ddsutils/ddsutils.h"
 #include "globalincs/systemvars.h"
+#include "graphics/2d.h"
 #include "graphics/grinternal.h"
 #include "math/vecmat.h"
 #include "options/Option.h"
@@ -89,28 +92,6 @@ static auto TextureFilteringOption __UNUSED = options::OptionBuilder<int>("Graph
                      .parser(parse_texture_filtering_func)
                      .finish();
 
-static SCP_vector<float> anisotropic_value_enumerator()
-{
-	float max;
-	if (!gr_get_property(gr_property::MAX_ANISOTROPY, &max)) {
-		return SCP_vector<float>();
-	}
-
-	if (max <= 2.0f) {
-		return SCP_vector<float>();
-	}
-
-	SCP_vector<float> out;
-
-	// We assume here that the anisotropy levels are powers of two...
-	float current = 1.0f;
-	while (current <= max) {
-		out.push_back(current);
-		current *= 2.0f;
-	}
-
-	return out;
-}
 static SCP_string anisotropic_display(float val)
 {
 	if (val < 2.0f) {
@@ -134,7 +115,7 @@ static float anisotropic_default()
 static auto AnisotropyOption = options::OptionBuilder<float>("Graphics.Anisotropy",
                      std::pair<const char*, int>{"Anistropic filtering", 1736},
                      std::pair<const char*, int>{"Controls the amount of anistropic filtering of the textures", 1737})
-                     .enumerator(anisotropic_value_enumerator)
+                     .enumerator(gr_get_supported_anisotropy_levels)
                      .category(std::make_pair("Graphics", 1825))
                      .display(anisotropic_display)
                      .default_func(anisotropic_default)
@@ -146,6 +127,27 @@ static auto AnisotropyOption = options::OptionBuilder<float>("Graphics.Anisotrop
 int opengl_free_texture(tcache_slot_opengl *t);
 int opengl_create_texture (int bitmap_handle, int bitmap_type, tcache_slot_opengl *tslot = NULL);
 
+// Running total of the bytes of texture data held by all live texture cache slots, for the
+// profiler overlay's memory panel. Kept in sync at every site that fills or drops a slot's data
+// rather than summed on demand, because the slots live in bmpman's blocks and a full walk of them
+// each frame is too expensive. Animations put all their frames in one texture array but give each
+// frame its own slot, so freeing some frames of an animation lowers this total while the array
+// itself stays alive until the last frame goes away.
+static size_t GL_texture_bytes_used = 0;
+
+/**
+ * @brief Removes a texture cache slot's bytes from GL_texture_bytes_used
+ *
+ * Call this at each site that drops the texture data of a slot, immediately before the code that
+ * clears the slot. The function sets the size of the slot to 0, thus a second call for the same
+ * slot does nothing.
+ */
+static void opengl_texture_release_bytes(tcache_slot_opengl* t)
+{
+	GL_texture_bytes_used -= static_cast<size_t>(t->size);
+	t->size = 0;
+}
+
 extern int get_num_mipmap_levels(int w, int h);
 
 void opengl_set_additive_tex_env()
@@ -189,8 +191,15 @@ void opengl_tcache_init()
 	// check what mipmap filter we should be using
 	//   0  ==  Bilinear
 	//   1  ==  Trilinear
+	// Seed from the legacy config key first: TextureFilteringOption's default_func returns
+	// GL_mipmap_filter, so this read is what supplies that default. Only then let the option
+	// override it, the same order the anisotropy setting below uses.
 	GL_mipmap_filter = os_config_read_uint(NULL, "TextureFilter", 1);
 
+	if (Using_in_game_options) {
+		GL_mipmap_filter = TextureFilteringOption->getValue();
+	}
+
 	if (GL_mipmap_filter > 1) {
 		GL_mipmap_filter = 1;
 	}
@@ -236,6 +245,14 @@ void opengl_tcache_flush()
 			opengl_free_texture(static_cast<tcache_slot_opengl*>(slot.gr_info));
 		}
 	}
+
+	// A flush releases the texture of every slot, thus the total must go to 0. A value that is not
+	// 0 shows that a site which drops texture data does not call opengl_texture_release_bytes().
+	// The shutdown sequence is the one exception: bm_close() removes the blocks before it closes
+	// the graphics backend, thus the loop above then finds no slot to release.
+	Assertion(bm_blocks.empty() || (GL_texture_bytes_used == 0),
+		"OpenGL texture memory tracking lost " SIZE_T_ARG " bytes. A texture release site is missing.",
+		GL_texture_bytes_used);
 }
 
 extern void opengl_kill_all_render_targets();
@@ -334,6 +351,7 @@ int opengl_free_texture(tcache_slot_opengl *t)
 			// There are still used frames left in the animation so we can't free the texture object here
 
 			// We still need to reset this slot though since it has been "freed"
+			opengl_texture_release_bytes(t);
 			t->reset();
 
 			// Everything is fine
@@ -353,6 +371,7 @@ int opengl_free_texture(tcache_slot_opengl *t)
 	glDeleteTextures (1, &t->texture_id);
 
 	// Finally, reset the data of this slot
+	opengl_texture_release_bytes(t);
 	t->reset();
 
 	return 1;
@@ -731,10 +750,14 @@ static int opengl_texture_set_level(int bitmap_handle, int bitmap_type, int bmap
 	} // end switch
 
 	tSlot->bitmap_handle = bitmap_handle;
+	// Remove the previous bytes of the slot before the new size replaces them. This function also
+	// runs for a texture that is filled again (a streaming animation, for example).
+	opengl_texture_release_bytes(tSlot);
 	tSlot->size          = (dsize) ? ((doffset + dsize) - skip_size) : (tex_w * tex_h * byte_mult);
 	tSlot->w             = (ushort)tex_w;
 	tSlot->h             = (ushort)tex_h;
 
+	GL_texture_bytes_used += static_cast<size_t>(tSlot->size);
 	GL_textures_in_frame += tSlot->size;
 
 	GL_CHECK_FOR_ERRORS("end of create_texture_sub()");
@@ -964,6 +987,7 @@ int opengl_create_texture(int bitmap_handle, int bitmap_type, tcache_slot_opengl
 			GL_state.Texture.Delete(start_slot->texture_id);
 			glDeleteTextures(1, &start_slot->texture_id);
 
+			opengl_texture_release_bytes(start_slot);
 			start_slot->reset();
 		}
 	}
@@ -1034,6 +1058,7 @@ int opengl_create_texture(int bitmap_handle, int bitmap_type, tcache_slot_opengl
 
 	if (tslot->texture_id == 0) {
 		mprintf(("!!OpenGL DEBUG!! t->texture_id == 0\n"));
+		opengl_texture_release_bytes(tslot);
 		tslot->reset();
 		return 0;
 	}
@@ -1110,7 +1135,13 @@ int opengl_create_texture(int bitmap_handle, int bitmap_type, tcache_slot_opengl
 		auto index = frame - animation_begin;
 
 		auto frame_slot = bm_get_gr_info<tcache_slot_opengl>(frame, true);
+		// The copy below overwrites the size of the slot, thus the old bytes must go away first
+		opengl_texture_release_bytes(frame_slot);
 		*frame_slot = *tslot; // Copy the existing properties to the slot of this texture
+		// The copy also brought in the size of tslot, which belongs to a different slot and is
+		// already part of GL_texture_bytes_used. opengl_texture_set_level() below gives this slot
+		// its own size.
+		frame_slot->size = 0;
 		frame_slot->array_index = (uint32_t) index;
 
 		// set the bits per pixel
@@ -1641,6 +1672,7 @@ struct fbo_t {
 	// these first vars should only be modified in opengl_make_render_target()
 	GLuint renderbuffer_id = 0;
 	GLuint framebuffer_id = 0;
+	size_t renderbuffer_bytes = 0; // for the profiler overlay's memory panel; see GL_renderbuffer_bytes_used
 	int width = 0;
 	int height = 0;
 	// these next 2 should only be modifed in opengl_set_render_target()
@@ -1653,6 +1685,12 @@ static SCP_vector<fbo_t> RenderTarget;
 static fbo_t *render_target = NULL;
 static int next_fbo_id = 0;
 
+// Running total of bytes used by depth/stencil renderbuffers across all live FBOs, for the
+// profiler overlay's memory panel. Kept in sync with each fbo_t's renderbuffer_bytes at every
+// create/delete site below rather than summed on demand, since RenderTarget entries are reused
+// (opengl_get_free_fbo) and reset in place.
+static size_t GL_renderbuffer_bytes_used = 0;
+
 static fbo_t* opengl_get_fbo(int id) {
 	if (id < 0) {
 		return nullptr;
@@ -1768,11 +1806,31 @@ void opengl_kill_render_target(bitmap_slot* slot)
 	if (fbo->renderbuffer_id) {
 		glDeleteRenderbuffers(1, &fbo->renderbuffer_id);
 		fbo->renderbuffer_id = 0;
+		GL_renderbuffer_bytes_used -= fbo->renderbuffer_bytes;
+		fbo->renderbuffer_bytes = 0;
 	}
 
 	opengl_free_fbo_slot(fbo->fbo_id);
 }
 
+void gr_opengl_get_memory_stats(gr_memory_stats& stats)
+{
+	stats.gpu_purpose_valid = true;
+
+	// The textures of the bitmap cache. Render targets that the game creates through bmpman are
+	// part of this group, which matches the Vulkan backend: its bm_make_render_target() images
+	// also go into the texture group.
+	stats.gpu_texture_bytes = GL_texture_bytes_used;
+
+	stats.gpu_geometry_bytes = opengl_get_geometry_bytes();
+
+	// The render target group holds the resources of the backend itself: the depth/stencil
+	// renderbuffers of the bitmap render targets, the scene and backbuffer textures, the
+	// post-processing textures, and the shadow map.
+	stats.gpu_render_target_bytes = GL_renderbuffer_bytes_used + opengl_get_scene_render_target_bytes() +
+									opengl_get_postprocessing_render_target_bytes() + opengl_get_shadow_map_bytes();
+}
+
 void opengl_kill_all_render_targets()
 {
 	for (size_t i = 0; i < RenderTarget.size(); i++) {
@@ -1786,10 +1844,18 @@ void opengl_kill_all_render_targets()
 		if (fbo->renderbuffer_id) {
 			glDeleteRenderbuffers(1, &fbo->renderbuffer_id);
 			fbo->renderbuffer_id = 0;
+			GL_renderbuffer_bytes_used -= fbo->renderbuffer_bytes;
+			fbo->renderbuffer_bytes = 0;
 		}
 	}
 
 	RenderTarget.clear();
+
+	// Every renderbuffer is gone now, thus the total must go to 0. A value that is not 0 shows
+	// that a site which deletes a renderbuffer does not correct GL_renderbuffer_bytes_used.
+	Assertion(GL_renderbuffer_bytes_used == 0,
+		"OpenGL renderbuffer memory tracking lost " SIZE_T_ARG " bytes. A renderbuffer delete site is missing.",
+		GL_renderbuffer_bytes_used);
 }
 
 int opengl_set_render_target( int slot, int face, int is_static )
@@ -1946,6 +2012,26 @@ int opengl_make_render_target( int handle, int *w, int *h, int *bpp, int *mm_lvl
 
 	glTexParameteri(GL_texture_target, GL_TEXTURE_MAX_LEVEL, ts->mipmap_levels - 1);
 
+	// Record the bytes of the color texture, which opengl_tex_array_storage() gave the format
+	// GL_RGBA8 (4 bytes for each pixel). A cube map holds 6 faces of that size.
+	size_t rt_texture_bytes = 0;
+	for (int level = 0; level < ts->mipmap_levels; ++level) {
+		auto level_w = static_cast<size_t>(std::max(1, *w >> level));
+		auto level_h = static_cast<size_t>(std::max(1, *h >> level));
+		rt_texture_bytes += level_w * level_h * 4;
+	}
+	if (flags & BMP_FLAG_CUBEMAP) {
+		rt_texture_bytes *= 6;
+	}
+	// A slot that held a render target before must lose its old bytes first.
+	opengl_texture_release_bytes(ts);
+
+	// The size field of the slot is an int, thus the value must stay inside its range. The counter
+	// takes the same (clamped) value, which keeps the add here and the subtract in
+	// opengl_texture_release_bytes() equal.
+	ts->size = static_cast<int>(std::min(rt_texture_bytes, static_cast<size_t>(INT_MAX)));
+	GL_texture_bytes_used += static_cast<size_t>(ts->size);
+
 	GL_state.Texture.Enable(0);
 
 	// render buffer (depth)
@@ -1954,6 +2040,10 @@ int opengl_make_render_target( int handle, int *w, int *h, int *bpp, int *mm_lvl
 		glBindRenderbuffer(GL_RENDERBUFFER, new_fbo->renderbuffer_id);
 		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, *w, *h);
 		glBindRenderbuffer(GL_RENDERBUFFER, 0);
+
+		// GL_DEPTH24_STENCIL8 is 4 bytes/pixel
+		new_fbo->renderbuffer_bytes = static_cast<size_t>(*w) * static_cast<size_t>(*h) * 4;
+		GL_renderbuffer_bytes_used += new_fbo->renderbuffer_bytes;
 	}
 
 	// frame buffer
@@ -1980,6 +2070,7 @@ int opengl_make_render_target( int handle, int *w, int *h, int *bpp, int *mm_lvl
 
 		GL_state.Texture.Delete(ts->texture_id);
 		glDeleteTextures(1, &ts->texture_id);
+		opengl_texture_release_bytes(ts);
 		ts->reset();
 
 		glDeleteFramebuffers(1, &new_fbo->framebuffer_id);
@@ -1987,6 +2078,8 @@ int opengl_make_render_target( int handle, int *w, int *h, int *bpp, int *mm_lvl
 		if (new_fbo->renderbuffer_id) {
 			glDeleteRenderbuffers(1, &new_fbo->renderbuffer_id);
 			new_fbo->renderbuffer_id = 0;
+			GL_renderbuffer_bytes_used -= new_fbo->renderbuffer_bytes;
+			new_fbo->renderbuffer_bytes = 0;
 		}
 
 		opengl_set_texture_target();

code/graphics/opengl/gropengltexture.h

@@ -81,6 +81,8 @@ void opengl_set_additive_tex_env();
 void opengl_set_modulate_tex_env();
 void opengl_preload_init();
 void opengl_kill_render_target(bitmap_slot* slot);
+struct gr_memory_stats;
+void gr_opengl_get_memory_stats(gr_memory_stats& stats);
 int opengl_make_render_target(int handle, int *w, int *h, int *bpp, int *mm_lvl, int flags);
 int opengl_set_render_target(int slot, int face = -1, int is_static = 0);
 ubyte* gr_opengl_get_bitmap_from_texture(int bitmap_num, int* width_out, int* height_out);

code/graphics/opengl/gropengltnl.cpp

@@ -59,15 +59,35 @@ extern vec3d G3_user_clip_point;
 extern bool Envmap_override;
 extern bool Shadow_override;
 
-size_t GL_vertex_data_in = 0;
+// Running total of the bytes held by live vertex and index buffers, for the profiler overlay's
+// memory panel (see opengl_get_geometry_bytes()). Uniform buffers and texture buffers stay out of
+// this total, which keeps it equal to the "geometry" group of the Vulkan backend.
+static size_t GL_geometry_bytes_used = 0;
+
+// Tells if a buffer of this OpenGL type counts as geometry for GL_geometry_bytes_used.
+static bool opengl_buffer_is_geometry(GLenum type)
+{
+	return (type == GL_ARRAY_BUFFER) || (type == GL_ELEMENT_ARRAY_BUFFER);
+}
+
+size_t opengl_get_geometry_bytes()
+{
+	return GL_geometry_bytes_used;
+}
 
 GLint GL_max_elements_vertices = 4096;
 GLint GL_max_elements_indices = 4096;
 
 GLuint Shadow_map_depth_texture = 0;
+GLuint Shadow_map_raw_sampler = 0;
 GLuint shadow_fbo = 0;
 int Shadow_texture_size = 0;
 
+// Number of layers in the shadow map texture array, kept from the moment
+// opengl_init_shadow_framebuffer() created the array. opengl_get_shadow_map_bytes() uses it, thus
+// a later change of the cascade counts cannot make that value wrong.
+static int Shadow_texture_layers = 0;
+
 gr_buffer_handle Transform_buffer_handle;
 
 SCP_unordered_map<vertex_layout, GLuint> Stored_vertex_arrays;
@@ -275,9 +295,11 @@ void gr_opengl_update_buffer_data(gr_buffer_handle handle, size_t size, const vo
 		glBufferData(buffer_obj.type, size, data, buffer_obj.gl_usage);
 	}
 
-	GL_vertex_data_in -= buffer_obj.size;
+	if (opengl_buffer_is_geometry(buffer_obj.type)) {
+		GL_geometry_bytes_used -= buffer_obj.size;
+		GL_geometry_bytes_used += size;
+	}
 	buffer_obj.size = size;
-	GL_vertex_data_in += buffer_obj.size;
 }
 
 void gr_opengl_update_buffer_data_offset(gr_buffer_handle handle, size_t offset, size_t size, const void* data)
@@ -365,7 +387,12 @@ void gr_opengl_delete_buffer(gr_buffer_handle handle)
 		glDeleteTextures(1, &buffer_obj.texture);
 	}
 
-	GL_vertex_data_in -= buffer_obj.size;
+	if (opengl_buffer_is_geometry(buffer_obj.type)) {
+		GL_geometry_bytes_used -= buffer_obj.size;
+	}
+	// The size must go to 0 here. opengl_destroy_all_buffers() calls this function for every
+	// handle, thus a buffer that the game already deleted comes through a second time.
+	buffer_obj.size = 0;
 
 	glDeleteBuffers(1, &buffer_obj.buffer_id);
 }
@@ -487,6 +514,25 @@ static bool opengl_init_shadow_framebuffer(int size)
 		// Everything is fine
 		mprintf(("Shadow framebuffer created successfully.\n"));
 		Shadow_texture_size = size;
+		Shadow_texture_layers = Num_shadow_cascades + Num_cockpit_shadow_cascades;
+
+		// Second sampler for Shadow_map_depth_texture, compare mode off, so PCSS blocker
+		// search (shadows.sdr) can read raw depth off the same texture that the compare
+		// sampler reads filtered visibility off -- see shadow_contact_hardening_supported()
+		// for why this needs a sampler object rather than a second glTexParameteri call.
+		if (shadow_contact_hardening_supported()) {
+			glGenSamplers(1, &Shadow_map_raw_sampler);
+			// GL_NEAREST: the blocker search wants the actual stored per-texel depth, not a
+			// hardware-filtered blend across the compare boundary -- deliberately different
+			// from the compare sampler's GL_LINEAR.
+			glSamplerParameteri(Shadow_map_raw_sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glSamplerParameteri(Shadow_map_raw_sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			glSamplerParameteri(Shadow_map_raw_sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glSamplerParameteri(Shadow_map_raw_sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+			glSamplerParameteri(Shadow_map_raw_sampler, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+			glSamplerParameteri(Shadow_map_raw_sampler, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+		}
+
 		return true;
 	}
 
@@ -517,29 +563,28 @@ static bool opengl_init_shadow_framebuffer(int size)
 	return false;
 }
 
+size_t opengl_get_shadow_map_bytes()
+{
+	if (Shadow_map_depth_texture == 0) {
+		return 0;
+	}
+
+	// opengl_init_shadow_framebuffer() gives the texture array the internal format
+	// GL_DEPTH_COMPONENT24, which the driver holds in 4 bytes for each texel.
+	constexpr size_t DEPTH_COMPONENT24_BYTES = 4;
+
+	const auto size = static_cast<size_t>(Shadow_texture_size);
+	const auto layers = static_cast<size_t>(Shadow_texture_layers);
+
+	return size * size * layers * DEPTH_COMPONENT24_BYTES;
+}
+
 void opengl_tnl_init()
 {
 	Transform_buffer_handle = opengl_create_texture_buffer_object();
 
 	if (Shadow_quality != ShadowQuality::Disabled) {
-		int size;
-		switch (Shadow_quality) {
-		case ShadowQuality::Low:
-			size = 512;
-			break;
-		case ShadowQuality::Medium:
-			size = 1024;
-			break;
-		case ShadowQuality::High:
-			size = 2048;
-			break;
-		case ShadowQuality::Ultra:
-			size = 4096;
-			break;
-		default:
-			size = 256;
-			break;
-		}
+		const int size = shadows_map_resolution();
 
 		if (!opengl_init_shadow_framebuffer(size)) {
 			mprintf(("Failed to create either shadow framebuffer. Disabling shadow support.\n"));
@@ -565,6 +610,16 @@ void opengl_tnl_shutdown()
 
 	shadow_cascade_params_shutdown();
 
+	if ( Shadow_map_raw_sampler ) {
+		// Clear the tracked bindings before deleting -- glDeleteSamplers silently unbinds
+		// the sampler from every unit on the GL side, which would leave GL_state's tracking
+		// stale (BindSampler() would then skip a rebind of a since-deleted sampler name).
+		GL_state.Texture.BindSampler(7, 0);
+		GL_state.Texture.BindSampler(11, 0);
+		glDeleteSamplers(1, &Shadow_map_raw_sampler);
+		Shadow_map_raw_sampler = 0;
+	}
+
 	if ( Shadow_map_depth_texture ) {
 		glDeleteTextures(1, &Shadow_map_depth_texture);
 		Shadow_map_depth_texture = 0;
@@ -917,8 +972,14 @@ void opengl_tnl_set_model_material(model_material *material_info)
 			Current_shader->program->Uniforms.setTextureUniform("sAmbientmap", 6);
 		if (setAllUniforms || (flags & MODEL_SDR_FLAG_MISC))
 			Current_shader->program->Uniforms.setTextureUniform("sMiscmap", 7);
-		if (setAllUniforms || (flags & MODEL_SDR_FLAG_SHADOWS))
+		if (setAllUniforms || (flags & MODEL_SDR_FLAG_SHADOWS)) {
 			Current_shader->program->Uniforms.setTextureUniform("shadow_map", 8);
+			// Unit 11 is reserved for this -- see the raw-sampler bind alongside "shadow_map"
+			// below. Set unconditionally (even when contact hardening is unsupported) for the
+			// same AMD unbound-uniform reason as the rest of this block; the shader's own
+			// penumbra_scale sentinel check is what prevents the read at runtime.
+			Current_shader->program->Uniforms.setTextureUniform("shadow_map_raw", 11);
+		}
 		Current_shader->program->Uniforms.setTextureUniform("sFramebuffer", 9);
 		if (setAllUniforms || (flags & MODEL_SDR_FLAG_TRANSFORM))
 			Current_shader->program->Uniforms.setTextureUniform("transform_tex", 10);
@@ -1001,6 +1062,10 @@ void opengl_tnl_set_model_material(model_material *material_info)
 
 		if (material_info->is_shadow_receiving()) {
 			GL_state.Texture.Enable(8, GL_TEXTURE_2D_ARRAY, Shadow_map_depth_texture);
+			if (Shadow_map_raw_sampler) {
+				GL_state.Texture.Enable(11, GL_TEXTURE_2D_ARRAY, Shadow_map_depth_texture);
+				GL_state.Texture.BindSampler(11, Shadow_map_raw_sampler);
+			}
 		}
 
 		if (material_info->get_animated_effect() >= 0) {

code/graphics/opengl/gropengltnl.h

@@ -35,6 +35,11 @@ extern float shadow_fardist;
 
 extern GLuint Shadow_map_depth_texture;
 
+// Second sampler object bound to Shadow_map_depth_texture, compare mode off, for the raw
+// (uncompared) depth reads PCSS blocker search needs. Only created when
+// shadow_contact_hardening_supported() is true; 0 otherwise. See gropengltnl.cpp.
+extern GLuint Shadow_map_raw_sampler;
+
 struct opengl_vertex_bind {
 	vertex_format_data::vertex_format format;
 	GLint size;
@@ -53,6 +58,22 @@ void gr_opengl_bind_uniform_buffer(uniform_block_type bind_point, size_t offset,
 void* gr_opengl_map_buffer(gr_buffer_handle handle);
 void gr_opengl_flush_mapped_buffer(gr_buffer_handle handle, size_t offset, size_t size);
 
+/**
+ * @brief Gives the bytes that all live vertex and index buffers hold
+ *
+ * The profiler overlay's memory panel shows this value as the "geometry" group. Uniform buffers
+ * and texture buffers are not part of it.
+ */
+size_t opengl_get_geometry_bytes();
+
+/**
+ * @brief Gives the bytes that the shadow map texture array holds
+ *
+ * The profiler overlay's memory panel adds this value to the "render targets" group. The function
+ * gives 0 when shadows are off.
+ */
+size_t opengl_get_shadow_map_bytes();
+
 /**
  * @brief Retrieves the OpenGL handle of a generic buffer handle
  * @param expected_type The expected type of the buffer. Mainly used for debug checking.

code/graphics/rtao.cpp

@@ -0,0 +1,50 @@
+#include "graphics/rtao.h"
+
+#include "graphics/2d.h"
+#include "graphics/shadows.h"
+#include "options/Option.h"
+
+int Rtao_samples = 0;
+
+// coverity[GLOBAL_INIT_ORDER] -- safe; OptionBuilder::finish() uses Meyers singleton
+auto RtaoQualityOption = options::OptionBuilder<int>("Graphics.RtaoQuality",
+                     std::pair<const char*, int>{"Raytraced Ambient Occlusion", -1},
+                     std::pair<const char*, int>{"Rays traced per pixel for ambient occlusion in the deferred ambient pass; Off keeps baked AO maps only", -1})
+                     .enumerator([]() -> SCP_vector<int> {
+                         if (rtao_supported()) {
+                             return {0, 4, 8, 16};
+                         }
+                         return {0}; // inert default when RT isn't supported
+                     })
+                     .display(options::MapValueDisplay<int>({
+                         {0, {"Off", -1}},
+                         {4, {"Low", -1}},
+                         {8, {"Medium", -1}},
+                         {16, {"High", -1}}
+                     }))
+                     .bind_to(&Rtao_samples)
+                     .flags({options::OptionFlags::ForceMultiValueSelection})
+                     .level(options::ExpertLevel::Advanced)
+                     .category(std::make_pair("Graphics", 1825))
+                     .default_func([]() { return 0; })
+                     .importance(71)
+                     .finish();
+
+bool rtao_supported()
+{
+	return gr_is_capable(gr_capability::CAPABILITY_RAYTRACED_SHADOWS);
+}
+
+bool rtao_enabled()
+{
+	// The shadow cascade parameters that RTAO reads are only created when shadows are on.
+	return Rtao_samples > 0 && rtao_supported() && Shadow_quality != ShadowQuality::Disabled;
+}
+
+void rtao_remove_unsupported_options()
+{
+	if (!rtao_supported()) {
+		// The option has no effect without raytracing support, so remove it.
+		options::OptionsManager::instance()->removeOption(RtaoQualityOption);
+	}
+}

code/graphics/rtao.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// Raytraced ambient occlusion (RTAO): short hemisphere occlusion rays traced via
+// inline ray query against the raytraced-shadow TLAS, inside the deferred ambient
+// light pass (LT_AMBIENT branch of deferred-f.sdr, RTAO shader variant). Composes
+// multiplicatively with baked AO maps through the shared G-buffer `ao` term, so
+// env-map/IBL ambient darkens consistently for free. The AO radius and strength
+// are content-scale-dependent and therefore mod-owned -- see $RTAO Radius: /
+// $RTAO Strength: in lighting_profiles.h.
+
+// Rays traced per pixel for ambient occlusion. 0 (the default) disables RTAO
+// entirely; nonzero values only take effect when rtao_supported(). Clamped
+// in-shader to RT_SHADOW_MAX_SAMPLES (16). See RtaoQualityOption in rtao.cpp.
+extern int Rtao_samples;
+
+// Whether the hardware/renderer can trace AO rays at all -- the same requirement
+// set as raytraced shadows (Vulkan + VK_KHR_acceleration_structure +
+// VK_KHR_ray_query), so this simply forwards to that capability.
+bool rtao_supported();
+
+// Whether the deferred ambient pass should trace AO this frame, i.e. the user has
+// enabled it, the hardware supports it, AND shadows are on. This is the single source of truth --
+// gate any RTAO shader-flag, TLAS-build, or uniform code on this, not on
+// Rtao_samples/rtao_supported() separately.
+bool rtao_enabled();
+
+// Remove the RTAO option from the options list when the renderer cannot trace rays.
+void rtao_remove_unsupported_options();

code/graphics/shader_types.cpp

@@ -133,6 +133,8 @@ static ShaderVariantInfo SHADER_VARIANTS[] = {
 
 	{SDR_TYPE_DEFERRED_LIGHTING, false, SDR_FLAG_DEFERRED_RT_SHADOWS, "RT_SHADOWS", {}, "Use raytraced (TLAS ray query) shadows instead of cascaded shadow maps"},
 
+	{SDR_TYPE_DEFERRED_LIGHTING, false, SDR_FLAG_DEFERRED_RTAO, "RTAO", {}, "Trace raytraced ambient occlusion in the ambient light pass"},
+
 	{SDR_TYPE_POST_PROCESS_BLUR, false, SDR_FLAG_BLUR_HORIZONTAL, "PASS_0", {}, "Horizontal blur pass"},
 
 	{SDR_TYPE_POST_PROCESS_BLUR, false, SDR_FLAG_BLUR_VERTICAL, "PASS_1", {}, "Vertical blur pass"},
@@ -221,7 +223,7 @@ bool shader_variant_requires_raytracing(shader_type type, unsigned int flags)
 	case SDR_TYPE_MODEL:
 		return (flags & MODEL_SDR_FLAG_RT_SHADOWS) != 0;
 	case SDR_TYPE_DEFERRED_LIGHTING:
-		return (flags & SDR_FLAG_DEFERRED_RT_SHADOWS) != 0;
+		return (flags & (SDR_FLAG_DEFERRED_RT_SHADOWS | SDR_FLAG_DEFERRED_RTAO)) != 0;
 	default:
 		return false;
 	}

code/graphics/shadows.cpp

@@ -16,7 +16,9 @@
 #include "cmdline/cmdline.h"
 #include "debris/debris.h"
 #include "graphics/matrix.h"
+#include "graphics/rtao.h"
 #include "lighting/lighting.h"
+#include "lighting/lighting_profiles.h"
 #include "math/vecmat.h"
 #include "mod_table/mod_table.h"
 #include "model/model.h"
@@ -27,9 +29,13 @@
 #include "ship/ship.h"
 #include "ship/shipfx.h"
 #include "render/3d.h"
+#include "starfield/starfield.h"
+#include "starfield/sun_disc.h"
 #include "tracing/tracing.h"
 #include "util/uniform_structs.h"
 
+#include <algorithm>
+
 extern vec3d check_offsets[8];
 
 matrix4 Shadow_view_matrix_light;
@@ -45,6 +51,7 @@ vec3d shadow_rt_relative(const vec3d& world_pos)
 }
 SCP_vector<matrix4> Shadow_proj_matrix;
 SCP_vector<float> Shadow_cascade_distances;
+SCP_vector<float> Shadow_penumbra_scale;
 
 static SCP_vector<light_frustum_info> Shadow_frustums;
 
@@ -243,13 +250,165 @@ auto RtShadowBiasMaxOption = options::OptionBuilder<float>("Graphics.RtShadowBia
                      .importance(74)
                      .finish();
 
+int Rt_shadow_samples_override = -1;
+
+bool Shadow_contact_hardening_enabled = true;
+
+// coverity[GLOBAL_INIT_ORDER] -- safe; OptionBuilder::finish() uses Meyers singleton
+auto ShadowContactHardeningOption = options::OptionBuilder<bool>("Graphics.ShadowContactHardening",
+                     std::pair<const char*, int>{"Shadow Contact Hardening", -1},
+                     std::pair<const char*, int>{"Sizes each shadow's penumbra by how close its occluder is, instead of a fixed blur width. Costs an extra shadow-map search per shadowed pixel", -1})
+                     // Only ever offered on hardware that can do the raw-depth read the
+                     // blocker search needs -- see shadow_contact_hardening_supported().
+                     .enumerator([]() -> SCP_vector<bool> {
+                         if (shadow_contact_hardening_supported()) {
+                             return {true, false};
+                         }
+                         return {false}; // inert default when unsupported
+                     })
+                     // Live-apply: shadows_start_render() reads Shadow_contact_hardening_enabled()
+                     // fresh every frame, no restart needed.
+                     .bind_to(&Shadow_contact_hardening_enabled)
+                     .flags({options::OptionFlags::ForceMultiValueSelection})
+                     .level(options::ExpertLevel::Advanced)
+                     .category(std::make_pair("Graphics", 1825))
+                     .default_func([]() { return true; })
+                     .importance(73)
+                     .finish();
+
 bool shadows_raytracing_supported()
 {
 	return gr_is_capable(gr_capability::CAPABILITY_RAYTRACED_SHADOWS);
 }
 
+bool shadow_contact_hardening_supported()
+{
+	return gr_is_capable(gr_capability::CAPABILITY_SHADOW_CONTACT_HARDENING);
+}
+
+bool shadow_contact_hardening_enabled()
+{
+	return shadow_contact_hardening_supported() && Shadow_contact_hardening_enabled;
+}
+
+int shadows_map_resolution()
+{
+	switch (Shadow_quality) {
+	case ShadowQuality::Low:    return 512;
+	case ShadowQuality::Medium: return 1024;
+	case ShadowQuality::High:   return 2048;
+	case ShadowQuality::Ultra:  return 4096;
+	default:                    return 512;
+	}
+}
+
+int shadows_rt_sample_count()
+{
+	if (Rt_shadow_samples_override > 0) {
+		return Rt_shadow_samples_override;
+	}
+
+	// The same tiers that pick the shadow map's resolution pick the ray count, so one
+	// setting covers "how much am I willing to spend on shadows" for either method. Low
+	// stays at a single ray -- that is the hard-shadow, one-ray-per-light floor, matching
+	// how a 512 map is the cheap floor for the other method rather than a soft-shadow
+	// setting the user has to find separately.
+	switch (Shadow_quality) {
+	case ShadowQuality::Low:    return 1;
+	case ShadowQuality::Medium: return 4;
+	case ShadowQuality::High:   return 8;
+	case ShadowQuality::Ultra:  return 16;
+	default:                    return 1;
+	}
+}
+
+// The apparent sun size the $Shadow Smoothness Factor: values are taken to be tuned against.
+// Sol is the natural choice: measured across the sun art of retail, the MediaVPs and several
+// mods, the calibration in sun_disc.cpp lands median content near Sol, and the shipped
+// smoothness defaults (1/300 .. 1/200) work out to a Sol-sized sun's penumbra at a blocker
+// distance of roughly 0.7-1.1 cascade widths. So a Sol-sized sun reproduces the look every
+// existing mod already tuned for, and everything else scales from there.
+static float shadow_smoothness_reference_tangent()
+{
+	return sun_disc_tangent_from_diameter(SUN_ANGULAR_SIZE_SOL);
+}
+
+// Softness of the shadow-mapped sun relative to that reference, i.e. the factor the tabled
+// smoothness values get scaled by.
+//
+// This is what makes shadow softness method-agnostic: the shadow map and the raytracer are
+// driven by the same number -- the tangent of the sun's angular radius, from $SunAngularSize:
+// or measured off the sun bitmap (see sun_angular_radius_tangent() in starfield.cpp). Doubling
+// a sun's apparent size doubles the raytraced penumbra cone and this filter width alike, so a
+// mission author tunes one parameter and both methods follow.
+//
+// Where shadow_contact_hardening_supported() is true, the value returned here no longer *is*
+// the penumbra radius -- it's the ceiling pcssPenumbraRadius() (shadows.sdr) clamps a real,
+// per-pixel, blocker-search-driven radius to (see Shadow_penumbra_scale). Where it's false
+// (GL below 3.3), it's still used directly as the fixed radius, exactly
+// as before contact hardening existed -- this function's output means "the widest the penumbra
+// is allowed to get" either way, which is why the tabled values keep their old meaning for mods
+// that already tuned them.
+//
+// Uses Static_light.front(), the same light shadows_start_render() builds the cascades from.
+// Every directional light that reaches this point carries a source radius: suns get theirs in
+// stars_draw_sun(), and common_setup_room_lights() -- the only other producer -- gives its
+// stand-in lights a sun's. A zero radius therefore means a genuinely sizeless source (a mod's
+// deliberately blank sun bitmap, say), which asks for a hard edge; the shadow map answers with
+// the narrowest filter it can, see shadow_clamp_smoothness().
+static float shadow_smoothness_scale()
+{
+	if (Static_light.empty()) {
+		return 1.0f;
+	}
+
+	const float reference = shadow_smoothness_reference_tangent();
+	if (reference <= 0.0f) {
+		return 1.0f;
+	}
+
+	// For directional lights source_radius is the tangent of the angular radius, not a
+	// world-space size -- see light_add_directional() in starfield.cpp's stars_draw_sun().
+	return Static_light.front().source_radius / reference;
+}
+
+// Keeps a derived filter width inside what the shadow map can actually represent.
+//
+// The floor is one texel: a sun small enough to want a sub-texel penumbra can't get one out of
+// a shadow map, and dropping below a texel only collapses all 16 Poisson taps into the same
+// texel -- paying for the taps and getting an aliased edge for it. (A raytraced shadow *does*
+// go properly hard there; this is a limit of the method, not of the parameter.)
+//
+// The ceiling bounds how far the taps spread. Missions set +AngularSize: freely, and a large
+// enough sun would scatter the 16 taps far enough apart to read as separate blobs, while the
+// comparison depth stays at the receiver and turns the widened filter into acne.
+//
+// Note the floor also applies to the tabled values themselves, so a mod that asked for a very
+// small $Shadow Smoothness Factor: gets widened to a texel at low shadow-map resolutions. That
+// value was already sub-texel there -- i.e. already doing nothing except cost taps -- so this
+// trades a hair of extra blur for an antialiased edge.
+static float shadow_clamp_smoothness(float smoothness)
+{
+	// shadows_map_resolution() is 512 at its smallest, so the floor always stays below the
+	// ceiling and std::clamp()'s lo <= hi precondition holds.
+	const float min_smoothness = 1.0f / static_cast<float>(shadows_map_resolution());
+	constexpr float max_smoothness = 0.02f;
+
+	return std::clamp(smoothness, min_smoothness, max_smoothness);
+}
+
 void shadows_remove_unsupported_options()
 {
+	rtao_remove_unsupported_options();
+
+	if (!shadow_contact_hardening_supported()) {
+		// No raw-depth sampler support (pre-3.3 OpenGL): the option is inert, so drop it.
+		// The bound global keeps its default; shadow_contact_hardening_enabled() folding
+		// in shadow_contact_hardening_supported() keeps rendering on the fixed-width
+		// fallback either way.
+		options::OptionsManager::instance()->removeOption(ShadowContactHardeningOption);
+	}
+
 	if (shadows_raytracing_supported()) {
 		return;
 	}
@@ -670,6 +829,9 @@ matrix shadows_start_render(matrix *eye_orient, vec3d *eye_pos, fov_t fov, fov_t
 	// Only ever do cockpit cascades if there's no override
 	bool render_cockpit_cascades = !cascade_distances_override.has_value() && ship_render_player_has_closeup_visuals();
 
+	// Computed once, not per-cascade -- see shadow_contact_hardening_enabled().
+	const bool contact_hardening_active = shadow_contact_hardening_enabled();
+
 	for (int i = 0; i < num_cascades; i++) {
 		float z_near;
 		if (i == 0 || (!render_cockpit_cascades && i == Num_cockpit_shadow_cascades)) {
@@ -682,6 +844,18 @@ matrix shadows_start_render(matrix *eye_orient, vec3d *eye_pos, fov_t fov, fov_t
 		shadows_construct_light_frustum(&Shadow_frustums[i], &light_matrix, eye_orient, nullptr, i < Num_cockpit_shadow_cascades ? cockpit_fov : fov, aspect, z_near, z_far);
 		Shadow_cascade_distances[i] = cascade_distances_actual[i];
 		Shadow_proj_matrix[i] = Shadow_frustums[i].proj_matrix;
+
+		// PCSS penumbra scale: world-space blocker/receiver depth separation (read back from
+		// the shadow map by the blocker search) times this equals the UV-space penumbra
+		// radius directly -- see the derivation next to shadow_smoothness_scale() below.
+		// Sentinel -1 when unsupported OR the user has the option off tells the shader to
+		// fall back to the fixed smoothness_factors[cascade] (today's behavior) instead of
+		// reading a raw depth sampler -- which either doesn't exist on this hardware, or
+		// does but isn't worth the extra shadow-map search right now.
+		Shadow_penumbra_scale[i] = contact_hardening_active
+			? std::max(0.0f, (Shadow_frustums[i].max.xyz.z - Shadow_frustums[i].min.xyz.z) * lp.source_radius /
+				(Shadow_frustums[i].max.xyz.x - Shadow_frustums[i].min.xyz.x))
+			: -1.0f;
 	}
 
 	gr_shadow_map_start(&Shadow_view_matrix_light, &light_matrix, eye_pos, true);
@@ -1020,6 +1194,10 @@ void shadow_end_frame() {
 static gr_buffer_handle Shadow_cascade_params_buffer;
 static size_t Shadow_cascade_params_buffer_size = 0;
 
+// Number of padded per-cascade float arrays shadow_cascade_params_bind() writes after the
+// proj matrices: cascade distances, smoothness factors, PCSS penumbra scale.
+static constexpr size_t Num_cascade_float_arrays = 3;
+
 static std::pair<size_t, size_t> compute_cascade_params_size(int num_cascades) {
 	size_t padding_required = num_cascades % 4;
 	if (padding_required != 0)
@@ -1027,11 +1205,23 @@ static std::pair<size_t, size_t> compute_cascade_params_size(int num_cascades) {
 
 	return {sizeof(graphics::shadow_cascade_static_data)
 		+ sizeof(matrix4) * num_cascades
-		+ sizeof(float) * (num_cascades + padding_required)
-		+ sizeof(float) * (num_cascades + padding_required),
+		+ Num_cascade_float_arrays * sizeof(float) * (num_cascades + padding_required),
 		padding_required};
 }
 
+// Writes num_cascades floats (value_at(0)..value_at(num_cascades - 1)) into buffer at offset,
+// advancing offset past both the values and the std140 padding that keeps the next field
+// vec4-aligned. Shared by shadow_cascade_params_bind()'s three per-cascade float arrays so the
+// offset/padding bookkeeping can't drift between them.
+template <typename F>
+static void write_padded_floats(SCP_vector<uint8_t>& buffer, size_t& offset, int num_cascades, size_t padding, F&& value_at) {
+	for (int i = 0; i < num_cascades; i++) {
+		*reinterpret_cast<float*>(buffer.data() + offset) = value_at(i);
+		offset += sizeof(float);
+	}
+	offset += sizeof(float) * padding;
+}
+
 void shadow_cascade_params_init() {
 	const int num_cascades = Num_shadow_cascades + Num_cockpit_shadow_cascades;
 	Shadow_cascade_params_buffer_size = compute_cascade_params_size(num_cascades).first;
@@ -1043,6 +1233,7 @@ void shadow_cascade_params_init() {
 	Shadow_frustums.resize(num_cascades);
 	Shadow_cascade_distances.resize(num_cascades);
 	Shadow_proj_matrix.resize(num_cascades);
+	Shadow_penumbra_scale.resize(num_cascades);
 }
 
 void shadow_cascade_params_shutdown() {
@@ -1062,7 +1253,7 @@ void shadow_cascade_params_bind(int cascade_offset, int cascade_count, const sha
 	const auto [required_size, padding] = compute_cascade_params_size(num_cascades);
 
 	Assertion(required_size <= Shadow_cascade_params_buffer_size, "The shadow cascade parameter buffer grew in size!");
-	Assertion(Shadow_proj_matrix.size() == static_cast<size_t>(num_cascades) && Shadow_cascade_distances.size() == static_cast<size_t>(num_cascades) && Shadow_smoothness_factor.size() == static_cast<size_t>(num_cascades), "Shadow cascade data buffers are of incorrect size! (Expected %d, got %d, %d, %d)", num_cascades, static_cast<int>(Shadow_proj_matrix.size()), static_cast<int>(Shadow_cascade_distances.size()), static_cast<int>(Shadow_smoothness_factor.size()));
+	Assertion(Shadow_proj_matrix.size() == static_cast<size_t>(num_cascades) && Shadow_cascade_distances.size() == static_cast<size_t>(num_cascades) && Shadow_smoothness_factor.size() == static_cast<size_t>(num_cascades) && Shadow_penumbra_scale.size() == static_cast<size_t>(num_cascades), "Shadow cascade data buffers are of incorrect size! (Expected %d, got %d, %d, %d, %d)", num_cascades, static_cast<int>(Shadow_proj_matrix.size()), static_cast<int>(Shadow_cascade_distances.size()), static_cast<int>(Shadow_smoothness_factor.size()), static_cast<int>(Shadow_penumbra_scale.size()));
 	Assertion(cascade_count + cascade_offset <= num_cascades, "Requested drawing out-of-range cascades!");
 
 	SCP_vector<uint8_t> buffer(required_size, 0);
@@ -1074,6 +1265,10 @@ void shadow_cascade_params_bind(int cascade_offset, int cascade_count, const sha
 	static_data.cascade_count = cascade_count;
 	static_data.rtShadowBiasMin = Rt_shadow_bias_min;
 	static_data.rtShadowBiasMax = Rt_shadow_bias_max;
+	static_data.rtShadowSampleCount = shadows_rt_sample_count();
+	static_data.rtaoSampleCount = Rtao_samples;
+	static_data.rtaoRadius = lighting_profiles::current_rtao_radius();
+	static_data.rtaoStrength = lighting_profiles::current_rtao_strength();
 	static_data.shadow_mv_matrix = Shadow_view_matrix_light;
 
 	static_data.shadow_ray_cull_mask = ray.cull_mask;
@@ -1089,19 +1284,20 @@ void shadow_cascade_params_bind(int cascade_offset, int cascade_count, const sha
 		offset += sizeof(matrix4);
 	}
 
-	for (int i = 0; i < num_cascades; i++) {
-		auto& cascade_distance = *reinterpret_cast<float*>(buffer.data() + offset);
-		cascade_distance = Shadow_cascade_distances[i];
-		offset += sizeof(float);
-	}
-	offset += sizeof(float) * padding;
+	write_padded_floats(buffer, offset, num_cascades, padding,
+		[](int i) { return Shadow_cascade_distances[i]; });
 
-	for (int i = 0; i < num_cascades; i++) {
-		auto& smoothness_factor = *reinterpret_cast<float*>(buffer.data() + offset);
-		smoothness_factor = Shadow_smoothness_factor[i];
-		offset += sizeof(float);
-	}
-	offset += sizeof(float) * padding;
+	// Scaled by the sun's apparent size so shadow-mapped and raytraced shadows soften
+	// together -- see shadow_smoothness_scale().
+	const float smoothness_scale = shadow_smoothness_scale();
+
+	write_padded_floats(buffer, offset, num_cascades, padding,
+		[smoothness_scale](int i) { return shadow_clamp_smoothness(Shadow_smoothness_factor[i] * smoothness_scale); });
+
+	// PCSS penumbra scale, appended last so every field above keeps its existing byte
+	// offset -- see Shadow_penumbra_scale's derivation comment in shadows.h.
+	write_padded_floats(buffer, offset, num_cascades, padding,
+		[](int i) { return Shadow_penumbra_scale[i]; });
 
 	// Full replacement, not _offset: this runs several times per frame with different content,
 	// and Vulkan's streaming buffer only bump-allocates fresh memory for a full update.

code/graphics/shadows.h

@@ -67,6 +67,32 @@ extern int Max_rt_shadow_local_lights;
 extern float Rt_shadow_bias_min;
 extern float Rt_shadow_bias_max;
 
+// Rays traced per pixel per shadowed light, for lights that have a source size --
+// suns from their drawn size, or from $SunAngularSize in stars.tbl when that
+// overrides it; local lights via their source_radius. 1 means the single hard ray
+// in traceShadowRayCone() (shadows.sdr); above that it samples a penumbra.
+//
+// This is a cost knob, not an appearance knob: how *wide* a penumbra is comes
+// solely from the light's source size, which is what also drives the shadow-map
+// path and keeps the two methods consistent for content authors. The sample count
+// only decides how well that penumbra resolves.
+//
+// Which is why it is not a setting of its own: it follows Shadow_quality
+// (Low/Medium/High/Ultra -> 1/4/8/16), the same tier that picks the shadow map's
+// resolution, so one control covers shadow cost whichever method is active.
+// Capped in-shader at RT_SHADOW_MAX_SAMPLES (16).
+int shadows_rt_sample_count();
+
+// Session-only override for shadows_rt_sample_count(), for iterating in the lab
+// without touching a persisted setting. <= 0 means "follow Shadow_quality".
+extern int Rt_shadow_samples_override;
+
+// Edge length, in texels, of one square cascade of the shadow map, as chosen by
+// Shadow_quality. Meaningless when Shadow_quality is Disabled (callers guard on that
+// first); the value returned in that case is only there to keep the result usable as a
+// divisor.
+int shadows_map_resolution();
+
 // Whether the current hardware/renderer can do anything with ShadowRenderMethod::Raytraced
 // at all (Vulkan + VK_KHR_acceleration_structure + VK_KHR_ray_query support). Independent
 // of which method is currently selected -- use this to decide whether to offer the choice.
@@ -105,6 +131,38 @@ constexpr uint8_t TLAS_MASK_ALL = 0xFF;
 constexpr uint8_t TLAS_MASK_VIEWER_HULL = 0x80;
 constexpr uint8_t SHADOW_RAY_CULL_MASK_EXCLUDE_VIEWER_HULL = static_cast<uint8_t>(~TLAS_MASK_VIEWER_HULL);
 
+// Per-cascade PCSS penumbra scale: world-space blocker/receiver depth separation, scaled
+// by the sun's tanθ and converted to UV space, gives the contact-hardened penumbra radius
+// directly (see the derivation comment above shadow_smoothness_scale() in shadows.cpp).
+// A negative value is a sentinel meaning shadow_contact_hardening_enabled() was false
+// when it was computed -- the shader falls back to the fixed smoothness_factors[cascade].
+extern SCP_vector<float> Shadow_penumbra_scale;
+
+// Whether the current renderer can do a raw (uncompared) depth read off the shadow map,
+// which PCSS blocker search needs. True on Vulkan always; on OpenGL requires
+// GL 3.3 (a second sampler object with compare mode off, bound to the
+// same shadow texture -- see shadow_map_raw in shadows.sdr). Independent of whether the
+// user currently has contact hardening turned on -- use this to decide whether to offer
+// the option at all.
+bool shadow_contact_hardening_supported();
+
+// User-facing toggle for shadow contact hardening (PCSS blocker search): sizes each
+// cascade's penumbra from actual occluder distance instead of the fixed
+// $Shadow Smoothness Factor: width. Costs an extra raw-depth search per shadowed pixel
+// (see pcssBlockerSearch() in shadows.sdr), so this is exposed as a setting rather than
+// being unconditional -- persisted via Graphics.ShadowContactHardening. See
+// shadow_contact_hardening_enabled() for the flag that actually gates the per-frame cost.
+extern bool Shadow_contact_hardening_enabled;
+
+// Whether shadow rendering should actually do the contact-hardening blocker search this
+// frame, i.e. shadow_contact_hardening_supported() is true AND the user has the option on.
+// This is the single source of truth -- gate any per-cascade penumbra-scale computation on
+// this, not on shadow_contact_hardening_supported()/Shadow_contact_hardening_enabled
+// separately. When false, Shadow_penumbra_scale gets the same negative sentinel as
+// "unsupported", so the shader takes the pre-contact-hardening fixed-width path at zero
+// extra cost (see pcssPenumbraRadius() in shadows.sdr).
+bool shadow_contact_hardening_enabled();
+
 void shadows_construct_light_frustum(vec3d *min_out, vec3d *max_out, vec3d light_vec, matrix *orient, vec3d *pos, fov_t fov, float aspect, float z_near, float z_far);
 bool shadows_obj_in_frustum(object *objp, vec3d *min, vec3d *max, matrix *light_orient);
 void shadows_render_all(fov_t fov, matrix *eye_orient, vec3d *eye_pos,

code/graphics/util/GPUMemoryHeap.cpp

@@ -70,6 +70,12 @@ void GPUMemoryHeap::freeGpuData(size_t offset) {
 gr_buffer_handle GPUMemoryHeap::bufferHandle() {
 	return _bufferHandle;
 }
+size_t GPUMemoryHeap::usedBytes() const {
+	return _allocator->usedBytes();
+}
+size_t GPUMemoryHeap::bufferSize() const {
+	return _bufferSize;
+}
 
 }
 }

code/graphics/util/GPUMemoryHeap.h

@@ -54,6 +54,18 @@ class GPUMemoryHeap {
 	 * @return The graphics code buffer handle.
 	 */
 	gr_buffer_handle bufferHandle();
+
+	/**
+	 * @brief Gets the number of bytes currently allocated from this heap
+	 * @return The sum of the sizes of all active allocations.
+	 */
+	size_t usedBytes() const;
+
+	/**
+	 * @brief Gets the total size of the backing GPU buffer, including both allocated and free space
+	 * @return The current buffer size.
+	 */
+	size_t bufferSize() const;
 };
 
 }

code/graphics/util/uniform_structs.h

@@ -2,6 +2,8 @@
 
 #include "globalincs/pstypes.h"
 
+#include <cstddef>
+
 using SPIRV_FLOAT_MAT_4x4 = matrix4;
 using SPIRV_FLOAT_VEC4 = vec4;
 
@@ -146,6 +148,14 @@ struct shadow_cascade_static_data {
 	int cascade_count;
 	float rtShadowBiasMin;
 	float rtShadowBiasMax;
+	int rtShadowSampleCount;
+	int rtaoSampleCount;
+	float rtaoRadius;
+	float rtaoStrength;
+	// The scalars above come to exactly 32 bytes, so std140 puts the following mat4
+	// straight after them with no padding. Adding or removing a scalar here changes
+	// that -- keep the C++ layout in lockstep with the shadowCascadeParams block
+	// declarations in deferred-f/main-f/main-v/shadow_map-g/shadow_map-v.sdr.
 	matrix4 shadow_mv_matrix;
 
 	// Position of the view-space origin (the camera) in TLAS-relative space. The RT shadow
@@ -173,13 +183,17 @@ struct shadow_cascade_static_data {
 	// main shadow cascades. Set in shadow_cascade_params_bind() (shadows.cpp).
 	int shadow_ray_cull_mask;
 };
+static_assert(offsetof(shadow_cascade_static_data, shadow_mv_matrix) == 32,
+	"shadow_cascade_static_data's scalar fields must total exactly 32 bytes to match std140's "
+	"mat4 alignment -- update the shadowCascadeParams block in every .sdr file that declares it "
+	"if this changes.");
 // Must match the GLSL shadowCascadeParams block's implicit std140 padding
-// exactly (16 [4 leading scalars] + 64 [matrix4] + 12 [shadow_ray_view_origin]
-// + 4 [shadow_ray_cull_mask, packed into the vec3's alignment padding] = 96) --
+// exactly (32 [8 leading scalars] + 64 [matrix4] + 12 [shadow_ray_view_origin]
+// + 4 [shadow_ray_cull_mask, packed into the vec3's alignment padding] = 112) --
 // shadow_cascade_params_bind() packs shadow_proj_matrix[] immediately after
 // this struct via sizeof(), so a mismatch here silently shifts every cascade
 // matrix in the buffer, in both backends.
-static_assert(sizeof(shadow_cascade_static_data) == 96, "shadow_cascade_static_data must match the GLSL shadowCascadeParams layout (see comment above)");
+static_assert(sizeof(shadow_cascade_static_data) == 112, "shadow_cascade_static_data must match the GLSL shadowCascadeParams layout (see comment above)");
 
 enum class NanoVGShaderType: int32_t {
 	FillGradient = 0, FillImage = 1, Simple = 2, Image = 3

code/graphics/vulkan/VulkanBuffer.cpp

@@ -339,7 +339,22 @@ vk::BufferUsageFlags VulkanBufferManager::getVkUsageFlags(BufferType type, bool
 	return flags;
 }
 
-MemoryUsage VulkanBufferManager::getMemoryUsage(BufferUsageHint hint) 
+namespace {
+MemoryPurpose bufferTypeToPurpose(BufferType type)
+{
+	switch (type) {
+	case BufferType::Vertex:
+	case BufferType::Index:
+		return MemoryPurpose::Geometry;
+	case BufferType::Uniform:
+	default:
+		// Uniform buffers are already tracked separately via UniformBufferManager/gr_debug_stats.
+		return MemoryPurpose::Unknown;
+	}
+}
+}
+
+MemoryUsage VulkanBufferManager::getMemoryUsage(BufferUsageHint hint)
 {
 	switch (hint) {
 	case BufferUsageHint::Static:
@@ -455,7 +470,8 @@ bool VulkanBufferManager::createOrResizeBuffer(VulkanBufferObject& bufferObj, si
 
 	// Allocate memory
 	MemoryUsage memUsage = getMemoryUsage(bufferObj.usage);
-	if (!m_memoryManager->allocateBufferMemory(bufferObj.buffer, memUsage, bufferObj.allocation)) {
+	if (!m_memoryManager->allocateBufferMemory(
+			bufferObj.buffer, memUsage, bufferObj.allocation, bufferTypeToPurpose(bufferObj.type))) {
 		m_device.destroyBuffer(bufferObj.buffer);
 		bufferObj.buffer = oldBuffer;
 		bufferObj.allocation = oldAllocation;

code/graphics/vulkan/VulkanBuffer.h

@@ -118,6 +118,12 @@ public:
 	 */
 	uint32_t getCurrentFrame() const { return m_currentFrame; }
 
+	/**
+	 * @brief Get the monotonic frame number set by setCurrentFrame (total frames
+	 * rendered, never wraps back -- unlike getCurrentFrame()'s in-flight slot index)
+	 */
+	uint64_t getCurrentFrameNumber() const { return m_currentFrameNumber; }
+
 	/**
 	 * @brief Get the Vulkan logical device
 	 */

code/graphics/vulkan/VulkanConvert.cpp

@@ -132,6 +132,20 @@ vk::PrimitiveTopology convertPrimitiveType(primitive_type type)
 	}
 }
 
+bool topologySupportsPrimitiveRestart(vk::PrimitiveTopology topology)
+{
+	switch (topology) {
+	case vk::PrimitiveTopology::eLineStrip:
+	case vk::PrimitiveTopology::eTriangleStrip:
+	case vk::PrimitiveTopology::eTriangleFan:
+	case vk::PrimitiveTopology::eLineStripWithAdjacency:
+	case vk::PrimitiveTopology::eTriangleStripWithAdjacency:
+		return true;
+	default:
+		return false;
+	}
+}
+
 vk::CullModeFlags convertCullMode(bool cullEnabled)
 {
 	return cullEnabled ? vk::CullModeFlagBits::eBack : vk::CullModeFlagBits::eNone;

code/graphics/vulkan/VulkanConvert.h

@@ -46,6 +46,15 @@ vk::StencilOp convertStencilOp(StencilOperation op);
  */
 vk::PrimitiveTopology convertPrimitiveType(primitive_type type);
 
+/**
+ * @brief Whether a topology may declare primitiveRestartEnable
+ *
+ * True for the strip/fan topologies. For list topologies the Vulkan spec requires
+ * primitiveRestartEnable to be VK_FALSE unless VK_EXT_primitive_topology_list_restart is
+ * enabled, which FSO does not request.
+ */
+bool topologySupportsPrimitiveRestart(vk::PrimitiveTopology topology);
+
 /**
  * @brief Convert FSO cull mode to Vulkan cull mode
  * @param cullEnabled Whether culling is enabled

code/graphics/vulkan/VulkanDeferred.cpp

@@ -19,6 +19,7 @@
 #include "graphics/matrix.h"
 #include "graphics/material.h"
 #include "graphics/grinternal.h"
+#include "graphics/rtao.h"
 #include "graphics/shadows.h"
 #include "lighting/lighting.h"
 #include "mission/missionparse.h"
@@ -374,13 +375,13 @@ void vulkan_deferred_lighting_msaa()
 			// Global set (fallback — resolve shader doesn't use global bindings)
 			vk::DescriptorSet globalSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Global);
 			Assert(globalSet);
-			writer.writeSet(globalSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Global));
+			writer.writeSet(DescriptorSetIndex::Global, globalSet);
 
 			// Material set: All 6 MSAA textures in binding 1 array (elements 0-5)
 			// [0]=color, [1]=position, [2]=normal, [3]=specular, [4]=emissive, [5]=depth
 			vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 			Assert(materialSet);
-			writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+			writer.writeSet(DescriptorSetIndex::Material, materialSet);
 
 			// Build texture array: elements 0-5 are MSAA textures, 6-15 are fallback
 			vk::Sampler nearestSampler = texMgr->getSampler(
@@ -402,7 +403,7 @@ void vulkan_deferred_lighting_msaa()
 			// PerDraw set: GenericData UBO with {samples, fov} at binding 0
 			vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 			Assert(perDrawSet);
-			writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+			writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 
 			struct MsaaResolveData {
 				int samples;
@@ -416,15 +417,8 @@ void vulkan_deferred_lighting_msaa()
 				ring.alloc(descriptorMgr->getCurrentFrame(), &resolveData, sizeof(resolveData));
 			writer.setBuffer(PerDrawBinding::GenericData, {ring.buffer(), slotOffset, ring.slotSize()});
 			writer.flush();
-			cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
-				pipelineMgr->getPipelineLayout(),
-				static_cast<uint32_t>(DescriptorSetIndex::Global), globalSet, {});
-			cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
-				pipelineMgr->getPipelineLayout(),
-				static_cast<uint32_t>(DescriptorSetIndex::Material), materialSet, {});
-			cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
-				pipelineMgr->getPipelineLayout(),
-				static_cast<uint32_t>(DescriptorSetIndex::PerDraw), perDrawSet, {});
+			const vk::DescriptorSet sets[] = {globalSet, materialSet, perDrawSet};
+			writer.bindSets(cmd, pipelineMgr->getPipelineLayout(), DescriptorSetIndex::Global, sets);
 
 			cmd.draw(3, 1, 0, 0);
 		}
@@ -545,10 +539,23 @@ void vulkan_deferred_lighting_finish()
 	auto* stateTracker = getStateTracker();
 	vk::CommandBuffer cmd = stateTracker->getCommandBuffer();
 
-	// 1. End G-buffer render pass
+	// TLAS for RTAO: when shadow rendering is off (Shadow_quality Disabled, or a
+	// frame that skips shadows_render_all entirely), nothing has built this
+	// frame's TLAS yet -- request it here. No-op when the shadow path already
+	// built it (buildTlas()'s per-frame guard). Acceleration-structure builds
+	// must be recorded outside a render pass, so this ends the G-buffer pass and
+	// clears it from the state tracker -- which is why step 1 below only ends
+	// the pass when it is still active.
+	if (rtao_enabled()) {
+		vulkan_build_shadow_tlas();
+	}
+
+	// 1. End G-buffer render pass (unless the RTAO TLAS build above already did)
 	// All 6 color attachments → eShaderReadOnlyOptimal
 	// Depth → eDepthStencilAttachmentOptimal
-	cmd.endRenderPass();
+	if (stateTracker->getCurrentRenderPass()) {
+		cmd.endRenderPass();
+	}
 
 	// 2. Copy emissive → composite (the emissive data becomes the base for light accumulation)
 	// Emissive → eShaderReadOnlyOptimal (done), composite → eColorAttachmentOptimal (for light accum)
@@ -1014,12 +1021,12 @@ void vulkan_render_decals(decal_material* material_info,
 	// Set 0: Global (all fallback)
 	vk::DescriptorSet globalSet = descManager->allocateFrameSet(DescriptorSetIndex::Global);
 	Assert(globalSet);
-	writer.writeSet(globalSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Global));
+	writer.writeSet(DescriptorSetIndex::Global, globalSet);
 
 	// Set 1: Material
 	vk::DescriptorSet materialSet = descManager->allocateFrameSet(DescriptorSetIndex::Material);
 	Assert(materialSet);
-	writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+	writer.writeSet(DescriptorSetIndex::Material, materialSet);
 
 	// Binding 2: DecalGlobals UBO
 	writer.setBuffer(MaterialBinding::DecalGlobals,
@@ -1053,15 +1060,19 @@ void vulkan_render_decals(decal_material* material_info,
 	// Set 2: PerDraw
 	vk::DescriptorSet perDrawSet = descManager->allocateFrameSet(DescriptorSetIndex::PerDraw);
 	Assert(perDrawSet);
-	writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+	writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 	writer.setBuffer(PerDrawBinding::Matrices,
 		getPendingBufInfo(static_cast<size_t>(uniform_block_type::Matrices)));
 	writer.setBuffer(PerDrawBinding::DecalInfo,
 		getPendingBufInfo(static_cast<size_t>(uniform_block_type::DecalInfo)));
 	writer.flush();
-	stateTracker->bindDescriptorSet(DescriptorSetIndex::Global, globalSet);
-	stateTracker->bindDescriptorSet(DescriptorSetIndex::Material, materialSet);
-	stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw, perDrawSet);
+	stateTracker->bindDescriptorSet(DescriptorSetIndex::Global, globalSet, nullptr);
+	stateTracker->bindDescriptorSet(DescriptorSetIndex::Material,
+		materialSet,
+		writer.dynamicOffsets(DescriptorSetIndex::Material));
+	stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw,
+		perDrawSet,
+		writer.dynamicOffsets(DescriptorSetIndex::PerDraw));
 
 	// Bind vertex buffers: binding 0 = box VBO, binding 1 = instance buffer
 	vk::Buffer boxVBO = bufferManager->getVkBuffer(buffers.Vbuffer_handle);

code/graphics/vulkan/VulkanDescriptorManager.cpp

@@ -15,10 +15,17 @@ static constexpr DescriptorBindingTemplate s_globalBindings[] = {
 	{GlobalBinding::EnvMap,        vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment, vk::ImageViewType::eCube},
 	{GlobalBinding::IrradianceMap, vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment, vk::ImageViewType::eCube},
 	{GlobalBinding::ShadowCascadeParams, vk::DescriptorType::eUniformBuffer,  1, vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
+	{GlobalBinding::ShadowMapRaw,  vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment, vk::ImageViewType::e2DArray},
 };
 static constexpr DescriptorBindingTemplate s_globalTlasBinding{
 	GlobalBinding::Tlas, vk::DescriptorType::eAccelerationStructureKHR, 1, vk::ShaderStageFlagBits::eFragment};
 
+// GLOBAL_DYNAMIC_OFFSET_COUNT is stated rather than derived because this set's template is
+// assembled at runtime (see below); keep the two in agreement. The optional TLAS binding is not
+// a dynamic UBO, so it cannot change the count either.
+static_assert(dynamic_offset_count(s_globalBindings) == GLOBAL_DYNAMIC_OFFSET_COUNT,
+	"The Global set gained a dynamic binding; GLOBAL_DYNAMIC_OFFSET_COUNT must follow.");
+
 // The Global set's layout must omit the TLAS binding entirely on devices without
 // VK_KHR_acceleration_structure enabled -- a descriptor type the device didn't
 // enable the extension for is invalid in vkCreateDescriptorSetLayout. So, unlike
@@ -27,26 +34,10 @@ static constexpr DescriptorBindingTemplate s_globalTlasBinding{
 // the per-instance m_globalBindingsRuntime/m_globalTemplateRuntime members
 // (see VulkanDescriptorManager.h), rather than compiled in as a fixed constexpr array.
 
-static constexpr DescriptorBindingTemplate s_materialBindings[] = {
-	{MaterialBinding::ModelData,     vk::DescriptorType::eUniformBuffer,        1,  vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
-	{MaterialBinding::TextureArray,  vk::DescriptorType::eCombinedImageSampler, 16, vk::ShaderStageFlagBits::eFragment, vk::ImageViewType::e2DArray},
-	{MaterialBinding::DecalGlobals,  vk::DescriptorType::eUniformBuffer,        1,  vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
-	{MaterialBinding::TransformSSBO, vk::DescriptorType::eStorageBuffer,        1,  vk::ShaderStageFlagBits::eVertex},
-	{MaterialBinding::DepthMap,      vk::DescriptorType::eCombinedImageSampler, 1,  vk::ShaderStageFlagBits::eFragment},
-	{MaterialBinding::SceneColor,    vk::DescriptorType::eCombinedImageSampler, 1,  vk::ShaderStageFlagBits::eFragment},
-	{MaterialBinding::DistortionMap, vk::DescriptorType::eCombinedImageSampler, 1,  vk::ShaderStageFlagBits::eFragment},
-	{MaterialBinding::ShadowMapData, vk::DescriptorType::eUniformBuffer,        1,  vk::ShaderStageFlagBits::eVertex},
-};
-static constexpr DescriptorSetTemplate s_materialTemplate(s_materialBindings);
-
-static constexpr DescriptorBindingTemplate s_perDrawBindings[] = {
-	{PerDrawBinding::GenericData, vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
-	{PerDrawBinding::Matrices,    vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
-	{PerDrawBinding::NanoVGData,  vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
-	{PerDrawBinding::DecalInfo,   vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
-	{PerDrawBinding::MovieData,   vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eFragment},
-};
-static constexpr DescriptorSetTemplate s_perDrawTemplate(s_perDrawBindings);
+// The binding declarations themselves live in the header (MaterialSetBindings /
+// PerDrawSetBindings) because the dynamic-offset layout is derived from them there.
+static constexpr DescriptorSetTemplate s_materialTemplate(MaterialSetBindings);
+static constexpr DescriptorSetTemplate s_perDrawTemplate(PerDrawSetBindings);
 
 // ========== Static uniform binding mappings ==========
 
@@ -92,12 +83,21 @@ const vk::DescriptorImageInfo& DescriptorFallbacks::getImage(vk::ImageViewType t
 
 // ========== DescriptorWriter template-based methods ==========
 
-void DescriptorWriter::writeSet(vk::DescriptorSet set, const DescriptorSetTemplate& tmpl)
+void DescriptorWriter::writeSet(DescriptorSetIndex setIndex, vk::DescriptorSet set)
 {
 	Assert(m_fallbacks);
 
+	const DescriptorSetTemplate& tmpl = VulkanDescriptorManager::getSetTemplate(setIndex);
+
 	// Clear binding slots for this set
 	m_bindingSlots = {};
+	m_currentSet = setIndex;
+
+	// Dynamic offsets are consumed in binding order, so assign slots as the template is walked
+	// (templates list bindings in ascending binding number). This must stay the same rule
+	// dynamic_offset_slot() applies — hence advancing by b.count, not by one binding.
+	uint32_t nextDynIndex = 0;
+	m_dynOffsets[static_cast<size_t>(setIndex)] = {};
 
 	for (const auto& b : tmpl) {
 		Assert(m_writeCount < MAX_WRITES);
@@ -116,6 +116,11 @@ void DescriptorWriter::writeSet(vk::DescriptorSet set, const DescriptorSetTempla
 
 		bool isImage = (b.type == vk::DescriptorType::eCombinedImageSampler);
 		bool isAccelStruct = (b.type == vk::DescriptorType::eAccelerationStructureKHR);
+		if (b.type == vk::DescriptorType::eUniformBufferDynamic) {
+			Assert(nextDynIndex + b.count <= MAX_DYNAMIC_OFFSETS_PER_SET);
+			slot.dynIndex = static_cast<int>(nextDynIndex);
+			nextDynIndex += b.count;
+		}
 		if (isImage) {
 			Assert(m_imageInfoCount + b.count <= MAX_IMAGE_INFOS);
 			auto* dst = &m_imageInfos[m_imageInfoCount];
@@ -144,12 +149,40 @@ void DescriptorWriter::writeSet(vk::DescriptorSet set, const DescriptorSetTempla
 		} else {
 			Assert(m_bufferInfoCount < MAX_BUFFER_INFOS);
 			m_bufferInfos[m_bufferInfoCount] = m_fallbacks->buffer;
+			// The fallback buffer info starts at offset 0, which is also the base a
+			// dynamic descriptor needs (its offset lives in the dynamic-offset array,
+			// left at 0 here until setBuffer supplies a real one).
 			w.pBufferInfo = &m_bufferInfos[m_bufferInfoCount];
 			slot.bufferInfo = &m_bufferInfos[m_bufferInfoCount++];
 		}
 	}
 }
 
+void DescriptorWriter::bindSets(vk::CommandBuffer cmd,
+	vk::PipelineLayout layout,
+	DescriptorSetIndex firstSet,
+	ArrayView<vk::DescriptorSet> sets)
+{
+	size_t out = 0;
+	for (size_t i = 0; i < sets.size; ++i) {
+		const auto set = static_cast<DescriptorSetIndex>(static_cast<uint32_t>(firstSet) + i);
+		Assert(static_cast<uint32_t>(set) < static_cast<uint32_t>(DescriptorSetIndex::Count));
+
+		const uint32_t dynCount = VulkanDescriptorManager::getDynamicOffsetCount(set);
+		Assert(dynCount <= MAX_DYNAMIC_OFFSETS_PER_SET);
+		for (uint32_t j = 0; j < dynCount; ++j) {
+			Assert(out < m_dynOffsetScratch.size());
+			m_dynOffsetScratch[out++] = m_dynOffsets[static_cast<size_t>(set)][j];
+		}
+	}
+
+	cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
+		layout,
+		static_cast<uint32_t>(firstSet),
+		vk::ArrayProxy<const vk::DescriptorSet>(static_cast<uint32_t>(sets.size), sets.data),
+		vk::ArrayProxy<const uint32_t>(static_cast<uint32_t>(out), m_dynOffsetScratch.data()));
+}
+
 void DescriptorWriter::flush()
 {
 	if (m_writeCount > 0) {
@@ -167,6 +200,25 @@ void DescriptorWriter::setBuffer(uint32_t binding, const vk::DescriptorBufferInf
 	Assert(binding < MAX_BINDINGS_PER_SET);
 	auto& slot = m_bindingSlots[binding];
 	Assert(slot.bufferInfo);
+
+	if (slot.dynIndex >= 0) {
+		// Dynamic binding: the descriptor holds only {buffer, 0, range}; the caller's
+		// offset becomes the dynamic offset applied at bind time. Keeping it out of
+		// the descriptor is what lets the set survive an offset-only change.
+		auto& dyn = m_dynOffsets[static_cast<size_t>(m_currentSet)][static_cast<size_t>(slot.dynIndex)];
+		if (info.buffer) {
+			Assertion(info.offset <= static_cast<vk::DeviceSize>(UINT32_MAX),
+				"Dynamic uniform buffer offset " SIZE_T_ARG " does not fit in a uint32 dynamic offset!",
+				static_cast<size_t>(info.offset));
+			*slot.bufferInfo = vk::DescriptorBufferInfo(info.buffer, 0, info.range);
+			dyn = static_cast<uint32_t>(info.offset);
+		} else {
+			*slot.bufferInfo = m_fallbacks->buffer;
+			dyn = 0;
+		}
+		return;
+	}
+
 	if (info.buffer) {
 		*slot.bufferInfo = info;
 	} else {
@@ -279,6 +331,23 @@ const DescriptorSetTemplate& VulkanDescriptorManager::getSetTemplate(DescriptorS
 	}
 }
 
+uint32_t VulkanDescriptorManager::getDynamicOffsetCount(DescriptorSetIndex setIndex)
+{
+	// Constant per set (see the derived *_DYNAMIC_OFFSET_COUNT values), not a scan of the
+	// template — this runs on every descriptor set bind.
+	switch (setIndex) {
+	case DescriptorSetIndex::Global:
+		return GLOBAL_DYNAMIC_OFFSET_COUNT;
+	case DescriptorSetIndex::Material:
+		return MATERIAL_DYNAMIC_OFFSET_COUNT;
+	case DescriptorSetIndex::PerDraw:
+		return PERDRAW_DYNAMIC_OFFSET_COUNT;
+	default:
+		UNREACHABLE("Invalid descriptor set index %u!", static_cast<uint32_t>(setIndex));
+		return 0;
+	}
+}
+
 vk::DescriptorSetLayout VulkanDescriptorManager::getSetLayout(DescriptorSetIndex setIndex) const
 {
 	return m_setLayouts[static_cast<size_t>(setIndex)].get();
@@ -294,22 +363,31 @@ vk::DescriptorSet VulkanDescriptorManager::allocateFrameSet(DescriptorSetIndex s
 	auto& pools = m_framePools[m_currentFrame];
 	++m_setsAllocatedThisFrame;
 
+	// Allocate through the non-throwing, non-allocating vulkan.hpp overload: this is
+	// one of the hottest calls in the backend (thousands per frame), and the
+	// vector-returning overload heap-allocates on every single one.
+	vk::DescriptorSetAllocateInfo allocInfo;
+	allocInfo.descriptorSetCount = 1;
+	allocInfo.pSetLayouts = &layout;
+
 	// Try allocating from the last pool in the list
 	if (!pools.empty()) {
-		vk::DescriptorSetAllocateInfo allocInfo;
 		allocInfo.descriptorPool = pools.back().get();
-		allocInfo.descriptorSetCount = 1;
-		allocInfo.pSetLayouts = &layout;
 
-		try {
-			auto sets = m_device.allocateDescriptorSets(allocInfo);
-			return sets[0];
-		} catch (const vk::OutOfPoolMemoryError&) {
-			// Pool exhausted, fall through to create a new one
+		vk::DescriptorSet set;
+		vk::Result result = m_device.allocateDescriptorSets(&allocInfo, &set);
+		if (result == vk::Result::eSuccess) {
+			return set;
+		}
+		if (result == vk::Result::eErrorOutOfPoolMemory) {
 			nprintf(("vulkan", "VulkanDescriptorManager: frame pool exhausted, allocating an additional pool chunk\n"));
-		} catch (const vk::FragmentedPoolError&) {
-			// Pool fragmented, fall through to create a new one
+		} else if (result == vk::Result::eErrorFragmentedPool) {
 			nprintf(("vulkan", "VulkanDescriptorManager: frame pool fragmented, allocating an additional pool chunk\n"));
+		} else {
+			nprintf(("vulkan",
+				"VulkanDescriptorManager: descriptor set allocation failed (%s)\n",
+				vk::to_string(result).c_str()));
+			return {};
 		}
 	}
 
@@ -318,18 +396,17 @@ vk::DescriptorSet VulkanDescriptorManager::allocateFrameSet(DescriptorSetIndex s
 	nprintf(("vulkandescriptor", "VulkanDescriptorManager: Grew frame %u pool count to %zu\n",
 		m_currentFrame, pools.size()));
 
-	vk::DescriptorSetAllocateInfo allocInfo;
 	allocInfo.descriptorPool = pools.back().get();
-	allocInfo.descriptorSetCount = 1;
-	allocInfo.pSetLayouts = &layout;
 
-	try {
-		auto sets = m_device.allocateDescriptorSets(allocInfo);
-		return sets[0];
-	} catch (const vk::SystemError& e) {
-		nprintf(("vulkan", "VulkanDescriptorManager: Failed to allocate frame descriptor set after pool growth: %s\n", e.what()));
+	vk::DescriptorSet set;
+	vk::Result result = m_device.allocateDescriptorSets(&allocInfo, &set);
+	if (result != vk::Result::eSuccess) {
+		nprintf(("vulkan",
+			"VulkanDescriptorManager: Failed to allocate frame descriptor set after pool growth: %s\n",
+			vk::to_string(result).c_str()));
 		return {};
 	}
+	return set;
 }
 
 void VulkanDescriptorManager::beginFrame()
@@ -403,9 +480,10 @@ vk::UniqueDescriptorPool VulkanDescriptorManager::createFramePool()
 	// constants in VulkanDescriptorManager.h. Additional pool chunks are created
 	// automatically when one is exhausted.
 	SCP_vector<vk::DescriptorPoolSize> poolSizes = {
-		{ vk::DescriptorType::eUniformBuffer, MAX_UNIFORM_BUFFERS_PER_POOL },
-		{ vk::DescriptorType::eCombinedImageSampler, MAX_SAMPLERS_PER_POOL },
-		{ vk::DescriptorType::eStorageBuffer, MAX_SETS_PER_POOL },
+		{vk::DescriptorType::eUniformBuffer, MAX_UNIFORM_BUFFERS_PER_POOL},
+		{vk::DescriptorType::eUniformBufferDynamic, MAX_DYNAMIC_UNIFORM_BUFFERS_PER_POOL},
+		{vk::DescriptorType::eCombinedImageSampler, MAX_SAMPLERS_PER_POOL},
+		{vk::DescriptorType::eStorageBuffer, MAX_SETS_PER_POOL},
 	};
 	if (m_raytracingEnabled) {
 		poolSizes.emplace_back(vk::DescriptorType::eAccelerationStructureKHR, MAX_SETS_PER_POOL);

code/graphics/vulkan/VulkanDescriptorManager.h

@@ -52,71 +52,6 @@ struct DescriptorFallbacks {
 	const vk::DescriptorImageInfo& getImage(vk::ImageViewType t) const;
 };
 
-/**
- * @brief Stack-allocated batch writer for descriptor set updates.
- *
- * Usage: reset() + writeSet() (pre-fills all bindings with fallbacks)
- * + setBuffer/setImage overrides for real data + flush().
- */
-class DescriptorWriter {
-public:
-	// Fixed capacities for the stack-allocated staging arrays below — NOT Vulkan
-	// hardware limits. They bound a single vkUpdateDescriptorSets batch (one
-	// writeSet), sized to comfortably cover the largest descriptor set layout the
-	// engine builds. Because the backing arrays live on the stack (see m_writes
-	// etc.), the numbers carry no runtime cost beyond that fixed footprint; the
-	// only failure mode is under-sizing, which is Assert-guarded at fill time in
-	// DescriptorWriter::writeSet (e.g. `Assert(m_writeCount < MAX_WRITES)`) so an
-	// oversized layout trips loudly in debug rather than silently overflowing.
-	// Raise these if a future set layout legitimately needs more bindings/infos.
-	static constexpr uint32_t MAX_WRITES = 32;           // distinct bindings written per batch
-	static constexpr uint32_t MAX_BUFFER_INFOS = 20;     // buffer descriptors staged per batch
-	static constexpr uint32_t MAX_IMAGE_INFOS = 24;      // image/sampler descriptors staged per batch
-	static constexpr uint32_t MAX_ACCEL_STRUCT_INFOS = 2; // TLAS descriptors staged per batch (RT)
-	static constexpr uint32_t MAX_BINDINGS_PER_SET = 16; // highest binding number addressable in a set
-
-	void reset(vk::Device device, const DescriptorFallbacks& fallbacks) {
-		m_device = device;
-		m_fallbacks = &fallbacks;
-		m_writeCount = 0;
-		m_bufferInfoCount = 0;
-		m_imageInfoCount = 0;
-		m_accelStructInfoCount = 0;
-	}
-
-	void writeSet(vk::DescriptorSet set, const DescriptorSetTemplate& tmpl);
-
-	void setBuffer(uint32_t binding, const vk::DescriptorBufferInfo& info);
-	void setImage(uint32_t binding, const vk::DescriptorImageInfo& info);
-	void setImageArray(uint32_t binding, ArrayView<vk::DescriptorImageInfo> infos);
-
-	void flush(); // defined in VulkanDescriptorManager.cpp (reports write stats to the manager)
-
-private:
-	// Per-binding lookup for the current writeSet, indexed by binding number.
-	// Populated by writeSet, used by setBuffer/setImage/setImageArray for O(1) access.
-	struct BindingSlot {
-		vk::DescriptorBufferInfo* bufferInfo = nullptr;  // non-null for buffer bindings
-		vk::DescriptorImageInfo* imageInfo = nullptr;    // non-null for image bindings
-		uint32_t count = 0;                              // descriptor count (1 or 16 for arrays)
-		vk::ImageViewType viewType = vk::ImageViewType::e2D;  // for fallback lookup
-	};
-
-	vk::Device m_device;
-	const DescriptorFallbacks* m_fallbacks = nullptr;
-
-	std::array<vk::WriteDescriptorSet, MAX_WRITES> m_writes;
-	std::array<vk::DescriptorBufferInfo, MAX_BUFFER_INFOS> m_bufferInfos;
-	std::array<vk::DescriptorImageInfo, MAX_IMAGE_INFOS> m_imageInfos;
-	std::array<vk::AccelerationStructureKHR, MAX_ACCEL_STRUCT_INFOS> m_accelStructInfos;
-	std::array<vk::WriteDescriptorSetAccelerationStructureKHR, MAX_ACCEL_STRUCT_INFOS> m_asWriteInfos;
-	std::array<BindingSlot, MAX_BINDINGS_PER_SET> m_bindingSlots;
-	uint32_t m_writeCount = 0;
-	uint32_t m_bufferInfoCount = 0;
-	uint32_t m_imageInfoCount = 0;
-	uint32_t m_accelStructInfoCount = 0;
-};
-
 /**
  * @brief Descriptor set indices for the 3-tier layout
  *
@@ -143,18 +78,22 @@ namespace GlobalBinding {
 	static constexpr uint32_t IrradianceMap = 4; // samplerCube: irradiance map
 	static constexpr uint32_t Tlas         = 5; // accelerationStructureEXT: raytraced shadow TLAS (only present when raytraced shadows are supported)
 	static constexpr uint32_t ShadowCascadeParams = 6; // UBO: shadow cascade projection matrices/distances (per-frame, shared by all consumers)
+	static constexpr uint32_t ShadowMapRaw = 7; // sampler2DArray: raw (non-compare) shadow map read, for PCSS blocker search
 }
 
 // Material Set (Set 1) bindings — per-material data
+// ModelData and ShadowMapData are *dynamic* UBOs: their offset moves every draw
+// while the rest of the set is unchanged, so keeping the offset out of the
+// descriptor is what makes the set cacheable across draws.
 namespace MaterialBinding {
-	static constexpr uint32_t ModelData    = 0; // UBO: model/material data
-	static constexpr uint32_t TextureArray = 1; // sampler2D[16]: material textures
-	static constexpr uint32_t DecalGlobals = 2; // UBO: decal globals
-	static constexpr uint32_t TransformSSBO = 3; // SSBO: batched transforms
-	static constexpr uint32_t DepthMap     = 4; // sampler2D: depth (soft particles)
-	static constexpr uint32_t SceneColor   = 5; // sampler2D: scene color (distortion)
-	static constexpr uint32_t DistortionMap = 6; // sampler2D: distortion texture
-	static constexpr uint32_t ShadowMapData = 7; // UBO: shadow map generation per-draw data (shadow_render_list)
+static constexpr uint32_t ModelData = 0;     // dynamic UBO: model/material data
+static constexpr uint32_t TextureArray = 1;  // sampler2D[16]: material textures
+static constexpr uint32_t DecalGlobals = 2;  // UBO: decal globals
+static constexpr uint32_t TransformSSBO = 3; // SSBO: batched transforms
+static constexpr uint32_t DepthMap = 4;      // sampler2D: depth (soft particles)
+static constexpr uint32_t SceneColor = 5;    // sampler2D: scene color (distortion)
+static constexpr uint32_t DistortionMap = 6; // sampler2D: distortion texture
+static constexpr uint32_t ShadowMapData = 7; // dynamic UBO: shadow map generation per-draw data (shadow_render_list)
 }
 
 // Texture array slot indices (elements within MaterialBinding::TextureArray)
@@ -169,14 +108,256 @@ namespace TextureSlot {
 }
 
 // PerDraw Set (Set 2) bindings — per-draw-call data
+// GenericData and Matrices are *dynamic* UBOs, for the same reason as the
+// Material set's ModelData.
 namespace PerDrawBinding {
-	static constexpr uint32_t GenericData  = 0; // UBO: generic shader data
-	static constexpr uint32_t Matrices     = 1; // UBO: transform matrices
-	static constexpr uint32_t NanoVGData   = 2; // UBO: NanoVG data
-	static constexpr uint32_t DecalInfo    = 3; // UBO: per-decal info
-	static constexpr uint32_t MovieData    = 4; // UBO: movie playback data
+static constexpr uint32_t GenericData = 0; // dynamic UBO: generic shader data
+static constexpr uint32_t Matrices = 1;    // dynamic UBO: transform matrices
+static constexpr uint32_t NanoVGData = 2;  // UBO: NanoVG data
+static constexpr uint32_t DecalInfo = 3;   // UBO: per-decal info
+static constexpr uint32_t MovieData = 4;   // UBO: movie playback data
 }
 
+// ========== Set layout templates ==========
+//
+// These describe the fixed set layouts. Everything downstream that needs to know
+// which bindings are dynamic, how many there are, or which dynamic-offset slot a
+// given binding occupies is derived from them below rather than restated, so the
+// declarations here are the only place that ordering exists.
+
+inline constexpr DescriptorBindingTemplate MaterialSetBindings[] = {
+	{MaterialBinding::ModelData,
+		vk::DescriptorType::eUniformBufferDynamic,
+		1,
+		vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
+	{MaterialBinding::TextureArray,
+		vk::DescriptorType::eCombinedImageSampler,
+		16,
+		vk::ShaderStageFlagBits::eFragment,
+		vk::ImageViewType::e2DArray},
+	{MaterialBinding::DecalGlobals,
+		vk::DescriptorType::eUniformBuffer,
+		1,
+		vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
+	{MaterialBinding::TransformSSBO, vk::DescriptorType::eStorageBuffer, 1, vk::ShaderStageFlagBits::eVertex},
+	{MaterialBinding::DepthMap, vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment},
+	{MaterialBinding::SceneColor, vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment},
+	{MaterialBinding::DistortionMap, vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment},
+	{MaterialBinding::ShadowMapData, vk::DescriptorType::eUniformBufferDynamic, 1, vk::ShaderStageFlagBits::eVertex},
+};
+
+inline constexpr DescriptorBindingTemplate PerDrawSetBindings[] = {
+	{PerDrawBinding::GenericData,
+		vk::DescriptorType::eUniformBufferDynamic,
+		1,
+		vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
+	{PerDrawBinding::Matrices,
+		vk::DescriptorType::eUniformBufferDynamic,
+		1,
+		vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
+	{PerDrawBinding::NanoVGData,
+		vk::DescriptorType::eUniformBuffer,
+		1,
+		vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
+	{PerDrawBinding::DecalInfo,
+		vk::DescriptorType::eUniformBuffer,
+		1,
+		vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
+	{PerDrawBinding::MovieData, vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eFragment},
+};
+
+// ========== Dynamic-offset layout, derived from the templates above ==========
+//
+// vkCmdBindDescriptorSets consumes a set's dynamic offsets in ascending binding
+// order, one entry per eUniformBufferDynamic descriptor. Both the count and the
+// slot each binding occupies are computed from the set templates so a call site
+// can never disagree with the layout it is binding against — reordering a template
+// moves the derived slots with it instead of silently feeding a shader the wrong
+// uniforms.
+
+template <size_t N>
+constexpr uint32_t dynamic_offset_count(const DescriptorBindingTemplate (&bindings)[N])
+{
+	uint32_t count = 0;
+	for (size_t i = 0; i < N; ++i) {
+		if (bindings[i].type == vk::DescriptorType::eUniformBufferDynamic) {
+			count += bindings[i].count;
+		}
+	}
+	return count;
+}
+
+// Returned by dynamic_offset_slot() when the binding is not a dynamic descriptor of the set.
+constexpr uint32_t DYNAMIC_SLOT_INVALID = ~0u;
+
+/**
+ * @brief Position of a dynamic binding within its set's dynamic-offset array
+ *
+ * If @c binding is not a dynamic binding of the given set, @c DYNAMIC_SLOT_INVALID is returned.
+ * Every use below pairs its constant with a static_assert against that sentinel, so a mistyped or
+ * non-dynamic binding constant is a compile error rather than a silent 0 — these constants index
+ * fixed-size dynamic-offset arrays at the bind call sites, so a leaked sentinel would be an
+ * out-of-bounds write.
+ *
+ * Do not "clean this up" back into a `throw` on the not-found path: MSVC rejects a constexpr
+ * function whose flow analysis can reach a throw (C3615), even when no evaluation takes that path.
+ */
+template <size_t N>
+constexpr uint32_t dynamic_offset_slot(const DescriptorBindingTemplate (&bindings)[N], uint32_t binding)
+{
+	uint32_t slot = 0;
+	for (size_t i = 0; i < N; ++i) {
+		if (bindings[i].type != vk::DescriptorType::eUniformBufferDynamic) {
+			continue;
+		}
+		if (bindings[i].binding == binding) {
+			return slot;
+		}
+		slot += bindings[i].count;
+	}
+	return DYNAMIC_SLOT_INVALID;
+}
+
+// The Global set declares no dynamic bindings; it contributes nothing to a bind call.
+constexpr uint32_t GLOBAL_DYNAMIC_OFFSET_COUNT = 0;
+constexpr uint32_t MATERIAL_DYNAMIC_OFFSET_COUNT = dynamic_offset_count(MaterialSetBindings);
+constexpr uint32_t PERDRAW_DYNAMIC_OFFSET_COUNT = dynamic_offset_count(PerDrawSetBindings);
+
+namespace MaterialDynamicSlot {
+constexpr uint32_t ModelData = dynamic_offset_slot(MaterialSetBindings, MaterialBinding::ModelData);
+constexpr uint32_t ShadowMapData = dynamic_offset_slot(MaterialSetBindings, MaterialBinding::ShadowMapData);
+static_assert(ModelData != DYNAMIC_SLOT_INVALID,
+	"MaterialBinding::ModelData is not a dynamic descriptor of the Material set.");
+static_assert(ShadowMapData != DYNAMIC_SLOT_INVALID,
+	"MaterialBinding::ShadowMapData is not a dynamic descriptor of the Material set.");
+}
+
+namespace PerDrawDynamicSlot {
+constexpr uint32_t GenericData = dynamic_offset_slot(PerDrawSetBindings, PerDrawBinding::GenericData);
+constexpr uint32_t Matrices = dynamic_offset_slot(PerDrawSetBindings, PerDrawBinding::Matrices);
+static_assert(GenericData != DYNAMIC_SLOT_INVALID,
+	"PerDrawBinding::GenericData is not a dynamic descriptor of the PerDraw set.");
+static_assert(Matrices != DYNAMIC_SLOT_INVALID,
+	"PerDrawBinding::Matrices is not a dynamic descriptor of the PerDraw set.");
+}
+
+/**
+ * @brief Stack-allocated batch writer for descriptor set updates.
+ *
+ * Usage: reset() + writeSet() (pre-fills all bindings with fallbacks)
+ * + setBuffer/setImage overrides for real data + flush().
+ *
+ * Bindings declared as eUniformBufferDynamic get their offset split out of the
+ * descriptor and into the dynamic-offset array (see dynamicOffsets()): setBuffer
+ * writes {buffer, 0, range} into the descriptor and stashes the caller's offset.
+ * That is what lets a set whose only per-draw change is a UBO offset be written
+ * once and rebound many times. Callers must hand dynamicOffsets()/
+ * VulkanDescriptorManager::getDynamicOffsetCount() for a set to
+ * vkCmdBindDescriptorSets when binding it.
+ */
+class DescriptorWriter {
+public:
+	// Fixed capacities for the stack-allocated staging arrays below — NOT Vulkan
+	// hardware limits. They bound a single vkUpdateDescriptorSets batch (one
+	// writeSet), sized to comfortably cover the largest descriptor set layout the
+	// engine builds. Because the backing arrays live on the stack (see m_writes
+	// etc.), the numbers carry no runtime cost beyond that fixed footprint; the
+	// only failure mode is under-sizing, which is Assert-guarded at fill time in
+	// DescriptorWriter::writeSet (e.g. `Assert(m_writeCount < MAX_WRITES)`) so an
+	// oversized layout trips loudly in debug rather than silently overflowing.
+	// Raise these if a future set layout legitimately needs more bindings/infos.
+	static constexpr uint32_t MAX_WRITES = 32;           // distinct bindings written per batch
+	static constexpr uint32_t MAX_BUFFER_INFOS = 20;     // buffer descriptors staged per batch
+	static constexpr uint32_t MAX_IMAGE_INFOS = 24;      // image/sampler descriptors staged per batch
+	static constexpr uint32_t MAX_ACCEL_STRUCT_INFOS = 2; // TLAS descriptors staged per batch (RT)
+	static constexpr uint32_t MAX_BINDINGS_PER_SET = 16; // highest binding number addressable in a set
+	// Most dynamic (eUniformBufferDynamic) bindings any one set layout declares. Derived from
+	// the templates rather than counted by hand, so adding a dynamic binding resizes the
+	// storage that holds its offset automatically.
+	static constexpr uint32_t MAX_DYNAMIC_OFFSETS_PER_SET =
+		MATERIAL_DYNAMIC_OFFSET_COUNT > PERDRAW_DYNAMIC_OFFSET_COUNT ? MATERIAL_DYNAMIC_OFFSET_COUNT
+																	 : PERDRAW_DYNAMIC_OFFSET_COUNT;
+
+	void reset(vk::Device device, const DescriptorFallbacks& fallbacks) {
+		m_device = device;
+		m_fallbacks = &fallbacks;
+		m_writeCount = 0;
+		m_bufferInfoCount = 0;
+		m_imageInfoCount = 0;
+		m_accelStructInfoCount = 0;
+		m_dynOffsets = {};
+	}
+
+	void writeSet(DescriptorSetIndex setIndex, vk::DescriptorSet set);
+
+	void setBuffer(uint32_t binding, const vk::DescriptorBufferInfo& info);
+	void setImage(uint32_t binding, const vk::DescriptorImageInfo& info);
+	void setImageArray(uint32_t binding, ArrayView<vk::DescriptorImageInfo> infos);
+
+	/**
+	 * @brief Dynamic offsets accumulated for a single set, ordered by binding number.
+	 *
+	 * Only meaningful for a set this writer actually wrote; a set reused from a
+	 * memoization cache was not written here, so its caller owns the offsets.
+	 * Always sized to the set layout's dynamic descriptor count (offsets for
+	 * bindings left at their fallback stay 0). Points at stable per-set storage —
+	 * valid until the next writeSet() of that set.
+	 */
+	const uint32_t* dynamicOffsets(DescriptorSetIndex setIndex) const
+	{
+		return m_dynOffsets[static_cast<size_t>(setIndex)].data();
+	}
+
+	/**
+	 * @brief Binds a contiguous run of sets in one vkCmdBindDescriptorSets call
+	 *
+	 * Concatenates the run's dynamic offsets in set order, which is the layout
+	 * vkCmdBindDescriptorSets expects: each set contributes exactly its layout's
+	 * dynamic descriptor count (a set declaring none contributes nothing, rather
+	 * than padding). @c sets must list the sets for @c firstSet onwards, in order.
+	 *
+	 * Binding here rather than handing the offsets back to the caller keeps the
+	 * concatenation buffer's lifetime contained: it is writer-owned scratch, reused
+	 * by the next call, and never outlives the command it was built for.
+	 */
+	void bindSets(vk::CommandBuffer cmd,
+		vk::PipelineLayout layout,
+		DescriptorSetIndex firstSet,
+		ArrayView<vk::DescriptorSet> sets);
+
+	void flush(); // defined in VulkanDescriptorManager.cpp (reports write stats to the manager)
+
+private:
+	// Per-binding lookup for the current writeSet, indexed by binding number.
+	// Populated by writeSet, used by setBuffer/setImage/setImageArray for O(1) access.
+	struct BindingSlot {
+		vk::DescriptorBufferInfo* bufferInfo = nullptr;  // non-null for buffer bindings
+		vk::DescriptorImageInfo* imageInfo = nullptr;    // non-null for image bindings
+		uint32_t count = 0;                              // descriptor count (1 or 16 for arrays)
+		vk::ImageViewType viewType = vk::ImageViewType::e2D;  // for fallback lookup
+		int dynIndex = -1;                                    // slot in m_dynOffsets, or -1 if not dynamic
+	};
+
+	vk::Device m_device;
+	const DescriptorFallbacks* m_fallbacks = nullptr;
+
+	std::array<vk::WriteDescriptorSet, MAX_WRITES> m_writes;
+	std::array<vk::DescriptorBufferInfo, MAX_BUFFER_INFOS> m_bufferInfos;
+	std::array<vk::DescriptorImageInfo, MAX_IMAGE_INFOS> m_imageInfos;
+	std::array<vk::AccelerationStructureKHR, MAX_ACCEL_STRUCT_INFOS> m_accelStructInfos;
+	std::array<vk::WriteDescriptorSetAccelerationStructureKHR, MAX_ACCEL_STRUCT_INFOS> m_asWriteInfos;
+	std::array<BindingSlot, MAX_BINDINGS_PER_SET> m_bindingSlots;
+	std::array<std::array<uint32_t, MAX_DYNAMIC_OFFSETS_PER_SET>, static_cast<size_t>(DescriptorSetIndex::Count)>
+		m_dynOffsets{};
+	// Scratch used by bindSets() to concatenate a run of sets' offsets.
+	std::array<uint32_t, static_cast<size_t>(DescriptorSetIndex::Count) * MAX_DYNAMIC_OFFSETS_PER_SET>
+		m_dynOffsetScratch{};
+	DescriptorSetIndex m_currentSet = DescriptorSetIndex::Global;
+	uint32_t m_writeCount = 0;
+	uint32_t m_bufferInfoCount = 0;
+	uint32_t m_imageInfoCount = 0;
+	uint32_t m_accelStructInfoCount = 0;
+};
 
 /**
  * @brief Manages Vulkan descriptor sets, pools, and layouts
@@ -195,8 +376,19 @@ public:
 	// larger chunks waste memory, smaller chunks allocate pools more often.
 	// MAX_SETS_PER_POOL supports ~330 draw calls (3 sets each) per chunk; the per-
 	// type multipliers cover the worst-case bindings a single set can request.
+	// One chunk now covers a dense scene outright: with the dynamic-UBO descriptor
+	// memoization in applyMaterial/renderShadowDraw, a big asteroid field at ~1350
+	// model draws settles at ~250 sets/frame, so growth is back to being the rare
+	// case it was meant to be. (The same scene needed ~2500 sets/frame before that.)
+	// Deliberately left at the original size rather than raised: the per-frame
+	// growth this used to log was a symptom of the churn, not of undersizing, and
+	// FSO targets low-end GPUs where a larger pool is real wasted memory.
 	static constexpr uint32_t MAX_SETS_PER_POOL = 1024;
-	static constexpr uint32_t MAX_UNIFORM_BUFFERS_PER_POOL = MAX_SETS_PER_POOL * 9;   // up to 9 UBOs per draw
+	// Worst case per set is 3 static UBOs (Global, PerDraw) and 2 dynamic (Material:
+	// ModelData + ShadowMapData; PerDraw: GenericData + Matrices). Total UBO
+	// capacity per chunk is slightly below what this was before the dynamic split.
+	static constexpr uint32_t MAX_UNIFORM_BUFFERS_PER_POOL = MAX_SETS_PER_POOL * 5;         // static UBOs
+	static constexpr uint32_t MAX_DYNAMIC_UNIFORM_BUFFERS_PER_POOL = MAX_SETS_PER_POOL * 2; // dynamic UBOs
 	static constexpr uint32_t MAX_SAMPLERS_PER_POOL = MAX_SETS_PER_POOL * 16;         // up to 16 samplers per material set
 
 	VulkanDescriptorManager() = default;
@@ -254,6 +446,15 @@ public:
 	 */
 	static const DescriptorSetTemplate& getSetTemplate(DescriptorSetIndex setIndex);
 
+	/**
+	 * @brief Number of dynamic (eUniformBufferDynamic) descriptors in a set layout
+	 *
+	 * vkCmdBindDescriptorSets requires exactly this many entries in pDynamicOffsets,
+	 * so every bind site must agree with the layout. VulkanStateTracker asserts on
+	 * it; raw cmd.bindDescriptorSets() callers should pass the matching count.
+	 */
+	static uint32_t getDynamicOffsetCount(DescriptorSetIndex setIndex);
+
 	/**
 	 * @brief Get descriptor set layout for a given set index
 	 */

code/graphics/vulkan/VulkanDraw.cpp

@@ -686,8 +686,12 @@ void VulkanDrawManager::renderModel(model_material* material_info, indexed_verte
 	stateTracker->getCommandBuffer().drawIndexed(dp.indexCount, 1, dp.firstIndex, dp.baseVertex, 0);
 }
 
-void VulkanDrawManager::renderShadowDraw(gr_buffer_handle ubo_handle, size_t ubo_offset, size_t ubo_size,
-                                          vertex_buffer* buffer, indexed_vertex_source* vert_src, size_t texi) const
+void VulkanDrawManager::renderShadowDraw(gr_buffer_handle ubo_handle,
+	size_t ubo_offset,
+	size_t ubo_size,
+	vertex_buffer* buffer,
+	indexed_vertex_source* vert_src,
+	size_t texi)
 {
 	if (!buffer || !vert_src) {
 		return;
@@ -754,51 +758,90 @@ void VulkanDrawManager::renderShadowDraw(gr_buffer_handle ubo_handle, size_t ubo
 	// (bound separately, per-frame, via shadow_cascade_params_bind) both live in
 	// the fixed 3-tier layout alongside the batched-submodel transform buffer;
 	// no material textures are needed for depth-only rendering.
+	//
+	// All three sets are memoized across the shadow pass (see m_cachedShadowSets).
+	// ShadowMapData is a dynamic binding, so the only thing that changes from one
+	// shadow draw to the next -- its UBO offset -- rides in the dynamic-offset array
+	// and leaves the set contents untouched. Without that this path allocated and
+	// fully rewrote three descriptor sets per shadow draw, times the cascade count.
 	{
-		DescriptorWriter writer;
-		writer.reset(descManager->getDevice(), descManager->getFallbacks());
-
-		vk::DescriptorSet globalSet = descManager->allocateFrameSet(DescriptorSetIndex::Global);
-		Assert(globalSet);
-		writer.writeSet(globalSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Global));
+		ShadowSetInputs shadowInputs;
 		{
-			const auto& pending = getPendingUniformBinding(static_cast<size_t>(uniform_block_type::ShadowCascadeParams));
-			if (pending.valid) {
-				vk::Buffer buf = bufferManager->getVkBuffer(pending.bufferHandle);
+			const auto& cascade =
+				getPendingUniformBinding(static_cast<size_t>(uniform_block_type::ShadowCascadeParams));
+			shadowInputs.cascadeHandle = cascade.bufferHandle.value();
+			shadowInputs.cascadeOffset = cascade.offset;
+			shadowInputs.cascadeSize = cascade.size;
+			shadowInputs.cascadeValid = cascade.valid;
+			shadowInputs.shadowDataHandle = ubo_handle.value();
+			shadowInputs.shadowDataSize = ubo_size; // offset is dynamic, so not part of the key
+			auto& tf = g_transformBuffers[descManager->getCurrentFrame()];
+			if (tf.buffer && tf.lastUploadSize > 0) {
+				shadowInputs.transformBuffer = tf.buffer;
+				shadowInputs.transformOffset = tf.lastUploadOffset;
+				shadowInputs.transformSize = tf.lastUploadSize;
+			}
+		}
+
+		if (!m_cachedShadowValid || shadowInputs != m_cachedShadowInputs) {
+			DescriptorWriter writer;
+			writer.reset(descManager->getDevice(), descManager->getFallbacks());
+
+			m_cachedShadowGlobalSet = descManager->allocateFrameSet(DescriptorSetIndex::Global);
+			Assert(m_cachedShadowGlobalSet);
+			writer.writeSet(DescriptorSetIndex::Global, m_cachedShadowGlobalSet);
+			if (shadowInputs.cascadeValid) {
+				vk::Buffer buf = bufferManager->getVkBuffer(gr_buffer_handle(shadowInputs.cascadeHandle));
 				if (buf) {
-					writer.setBuffer(GlobalBinding::ShadowCascadeParams, {buf, pending.offset, pending.size});
+					writer.setBuffer(GlobalBinding::ShadowCascadeParams,
+						{buf, shadowInputs.cascadeOffset, shadowInputs.cascadeSize});
 				}
 			}
-		}
 
-		vk::DescriptorSet materialSet = descManager->allocateFrameSet(DescriptorSetIndex::Material);
-		Assert(materialSet);
-		writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
-		{
-			vk::Buffer buf = bufferManager->getVkBuffer(ubo_handle);
-			if (buf) {
-				writer.setBuffer(MaterialBinding::ShadowMapData,
-					{buf, static_cast<vk::DeviceSize>(ubo_offset), static_cast<vk::DeviceSize>(ubo_size)});
+			m_cachedShadowMaterialSet = descManager->allocateFrameSet(DescriptorSetIndex::Material);
+			Assert(m_cachedShadowMaterialSet);
+			writer.writeSet(DescriptorSetIndex::Material, m_cachedShadowMaterialSet);
+			{
+				vk::Buffer buf = bufferManager->getVkBuffer(ubo_handle);
+				if (buf) {
+					// Offset 0: the real offset is supplied per draw as a dynamic offset.
+					writer.setBuffer(MaterialBinding::ShadowMapData, {buf, 0, static_cast<vk::DeviceSize>(ubo_size)});
+				}
 			}
-		}
-		{
-			uint32_t tfIdx = descManager->getCurrentFrame();
-			auto& tf = g_transformBuffers[tfIdx];
-			if (tf.buffer && tf.lastUploadSize > 0) {
-				writer.setBuffer(MaterialBinding::TransformSSBO, {tf.buffer,
-				                 static_cast<vk::DeviceSize>(tf.lastUploadOffset),
-				                 static_cast<vk::DeviceSize>(tf.lastUploadSize)});
+			if (shadowInputs.transformBuffer) {
+				writer.setBuffer(MaterialBinding::TransformSSBO,
+					{shadowInputs.transformBuffer,
+						static_cast<vk::DeviceSize>(shadowInputs.transformOffset),
+						static_cast<vk::DeviceSize>(shadowInputs.transformSize)});
 			}
+
+			m_cachedShadowPerDrawSet = descManager->allocateFrameSet(DescriptorSetIndex::PerDraw);
+			Assert(m_cachedShadowPerDrawSet);
+			writer.writeSet(DescriptorSetIndex::PerDraw, m_cachedShadowPerDrawSet);
+			writer.flush();
+
+			m_cachedShadowInputs = shadowInputs;
+			m_cachedShadowValid = true;
 		}
 
-		vk::DescriptorSet perDrawSet = descManager->allocateFrameSet(DescriptorSetIndex::PerDraw);
-		Assert(perDrawSet);
-		writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
-		writer.flush();
+		// applyMaterial's caches deliberately are NOT invalidated here. They record
+		// what a descriptor set *contains*, and the shadow pass allocates its own
+		// sets rather than overwriting theirs. Which set is currently bound is
+		// tracked separately by VulkanStateTracker, and this path binds through it,
+		// so the next applyMaterial cache hit still rebinds its set correctly. (That
+		// is what separates this from the ImGui case invalidateDrawStateCaches()
+		// exists for: ImGui binds on the command buffer behind the tracker's back.)
 
-		stateTracker->bindDescriptorSet(DescriptorSetIndex::Global, globalSet);
-		stateTracker->bindDescriptorSet(DescriptorSetIndex::Material, materialSet);
-		stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw, perDrawSet);
+		// ShadowMapData is the one thing that moves per shadow draw; every other dynamic binding
+		// on this path holds the fallback buffer and so must stay at offset 0.
+		uint32_t materialDynOffsets[MATERIAL_DYNAMIC_OFFSET_COUNT] = {};
+		materialDynOffsets[MaterialDynamicSlot::ShadowMapData] = static_cast<uint32_t>(ubo_offset);
+
+		static constexpr uint32_t perDrawDynOffsets[PERDRAW_DYNAMIC_OFFSET_COUNT] = {};
+
+		stateTracker->bindDescriptorSet(DescriptorSetIndex::Global, m_cachedShadowGlobalSet, nullptr);
+		stateTracker->bindDescriptorSet(DescriptorSetIndex::Material, m_cachedShadowMaterialSet, materialDynOffsets);
+		stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw, m_cachedShadowPerDrawSet, perDrawDynOffsets);
 	}
 
 	vk::Buffer vbuffer = bufferManager->getVkBuffer(vert_src->Vbuffer_handle);
@@ -960,6 +1003,10 @@ void VulkanDrawManager::resetFrameStats()
 	m_cachedMaterialValid = false;
 	m_cachedPerDrawSet = nullptr;
 	m_cachedPerDrawValid = false;
+	m_cachedShadowGlobalSet = nullptr;
+	m_cachedShadowMaterialSet = nullptr;
+	m_cachedShadowPerDrawSet = nullptr;
+	m_cachedShadowValid = false;
 }
 
 void VulkanDrawManager::printFrameStats()
@@ -1349,6 +1396,28 @@ bool VulkanDrawManager::applyMaterial(material* mat, primitive_type prim_type, v
 			}
 		};
 
+		// Dynamic offsets for the Material/PerDraw sets, ordered by binding number.
+		// Computed here rather than read back from the writer because the whole point
+		// of the dynamic bindings is that these change on draws where the set itself
+		// is reused from cache and never written.
+		const auto dynOffsetOf = [&](uniform_block_type blockType) -> uint32_t {
+			const auto& pending = m_pendingUniformBindings[static_cast<size_t>(blockType)];
+			if (!pending.valid || !bufferManager->getVkBuffer(pending.bufferHandle)) {
+				return 0; // falls back to the dummy buffer, which is bound at offset 0
+			}
+			return static_cast<uint32_t>(pending.offset);
+		};
+		// Zero-initialized, then filled by name: MaterialDynamicSlot::ShadowMapData is left at 0
+		// because ShadowMapData is never bound on this path, so its descriptor still holds the
+		// fallback buffer -- bound as {buffer, 0, FALLBACK_UNIFORM_BUFFER_SIZE}, i.e. spanning the
+		// whole buffer, so any non-zero dynamic offset would push offset+range past the end of it.
+		uint32_t materialDynOffsets[MATERIAL_DYNAMIC_OFFSET_COUNT] = {};
+		materialDynOffsets[MaterialDynamicSlot::ModelData] = dynOffsetOf(uniform_block_type::ModelData);
+
+		uint32_t perDrawDynOffsets[PERDRAW_DYNAMIC_OFFSET_COUNT] = {};
+		perDrawDynOffsets[PerDrawDynamicSlot::GenericData] = dynOffsetOf(uniform_block_type::GenericData);
+		perDrawDynOffsets[PerDrawDynamicSlot::Matrices] = dynOffsetOf(uniform_block_type::Matrices);
+
 		// Set 0: Global (memoized per frame — see m_cachedGlobalSet). Rebuilt only
 		// when a Global input changed: a pending Global UBO (m_globalSetDirty set in
 		// setPendingUniformBinding), the shadow TLAS (invalidateGlobalSet from
@@ -1360,10 +1429,11 @@ bool VulkanDrawManager::applyMaterial(material* mat, primitive_type prim_type, v
 		if (m_globalSetDirty || !m_cachedGlobalSet || shadowReady != m_cachedGlobalHadShadow) {
 			m_cachedGlobalSet = descManager->allocateFrameSet(DescriptorSetIndex::Global);
 			Assert(m_cachedGlobalSet);
-			writer.writeSet(m_cachedGlobalSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Global));
+			writer.writeSet(DescriptorSetIndex::Global, m_cachedGlobalSet);
 			bindPendingUBOs(DescriptorSetIndex::Global);
 			if (shadowReady) {
 				writer.setImage(GlobalBinding::ShadowMap, pp->getShadowTextureInfo());
+				writer.setImage(GlobalBinding::ShadowMapRaw, pp->getShadowRawTextureInfo());
 			}
 			m_cachedGlobalHadShadow = shadowReady;
 			m_globalSetDirty = false;
@@ -1397,9 +1467,14 @@ bool VulkanDrawManager::applyMaterial(material* mat, primitive_type prim_type, v
 		matInputs.sceneColorInfo = m_sceneColorInfo;
 		matInputs.distMapInfo = m_distMapInfo;
 		{
+			// ModelData's offset is deliberately NOT part of the key: it is a dynamic
+			// binding, so an offset-only change is carried by materialDynOffsets and
+			// leaves the set's contents identical. Buffer and size still matter --
+			// both live in the descriptor.
 			const auto& md = m_pendingUniformBindings[static_cast<size_t>(uniform_block_type::ModelData)];
 			const auto& dg = m_pendingUniformBindings[static_cast<size_t>(uniform_block_type::DecalGlobals)];
-			matInputs.uboHandle[0] = md.bufferHandle.value(); matInputs.uboOffset[0] = md.offset;
+			matInputs.uboHandle[0] = md.bufferHandle.value();
+			matInputs.uboOffset[0] = 0;
 			matInputs.uboSize[0] = md.size; matInputs.uboValid[0] = md.valid;
 			matInputs.uboHandle[1] = dg.bufferHandle.value(); matInputs.uboOffset[1] = dg.offset;
 			matInputs.uboSize[1] = dg.size; matInputs.uboValid[1] = dg.valid;
@@ -1413,7 +1488,7 @@ bool VulkanDrawManager::applyMaterial(material* mat, primitive_type prim_type, v
 		} else {
 			materialSet = descManager->allocateFrameSet(DescriptorSetIndex::Material);
 			Assert(materialSet);
-			writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+			writer.writeSet(DescriptorSetIndex::Material, materialSet);
 			bindPendingUBOs(DescriptorSetIndex::Material);
 			if (matInputs.transformBuffer) {
 				writer.setBuffer(MaterialBinding::TransformSSBO,
@@ -1433,14 +1508,23 @@ bool VulkanDrawManager::applyMaterial(material* mat, primitive_type prim_type, v
 		// Set 2: PerDraw (previous-set memoized — see m_cachedPerDrawSet)
 		PerDrawSetInputs pdInputs;
 		{
-			static constexpr uniform_block_type pdTypes[NUM_PERDRAW_UBOS] = {
-				uniform_block_type::GenericData, uniform_block_type::Matrices,
-				uniform_block_type::NanoVGData, uniform_block_type::DecalInfo,
-				uniform_block_type::MovieData};
+			struct PerDrawUbo {
+				uniform_block_type blockType;
+				uint32_t binding;
+			};
+			static constexpr PerDrawUbo pdUbos[NUM_PERDRAW_UBOS] = {
+				{uniform_block_type::GenericData, PerDrawBinding::GenericData},
+				{uniform_block_type::Matrices, PerDrawBinding::Matrices},
+				{uniform_block_type::NanoVGData, PerDrawBinding::NanoVGData},
+				{uniform_block_type::DecalInfo, PerDrawBinding::DecalInfo},
+				{uniform_block_type::MovieData, PerDrawBinding::MovieData}};
 			for (int i = 0; i < NUM_PERDRAW_UBOS; ++i) {
-				const auto& p = m_pendingUniformBindings[static_cast<size_t>(pdTypes[i])];
+				const auto& p = m_pendingUniformBindings[static_cast<size_t>(pdUbos[i].blockType)];
 				pdInputs.uboHandle[i] = p.bufferHandle.value();
-				pdInputs.uboOffset[i] = p.offset;
+				// The offset of a dynamic binding rides in perDrawDynOffsets and is not part
+				// of the set's contents.
+				const bool dynamic = dynamic_offset_slot(PerDrawSetBindings, pdUbos[i].binding) != DYNAMIC_SLOT_INVALID;
+				pdInputs.uboOffset[i] = dynamic ? 0 : p.offset;
 				pdInputs.uboSize[i] = p.size;
 				pdInputs.uboValid[i] = p.valid;
 			}
@@ -1452,16 +1536,16 @@ bool VulkanDrawManager::applyMaterial(material* mat, primitive_type prim_type, v
 		} else {
 			perDrawSet = descManager->allocateFrameSet(DescriptorSetIndex::PerDraw);
 			Assert(perDrawSet);
-			writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+			writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 			bindPendingUBOs(DescriptorSetIndex::PerDraw);
 			m_cachedPerDrawSet = perDrawSet;
 			m_cachedPerDrawInputs = pdInputs;
 			m_cachedPerDrawValid = true;
 		}
 		writer.flush();
-		stateTracker->bindDescriptorSet(DescriptorSetIndex::Global, globalSet);
-		stateTracker->bindDescriptorSet(DescriptorSetIndex::Material, materialSet);
-		stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw, perDrawSet);
+		stateTracker->bindDescriptorSet(DescriptorSetIndex::Global, globalSet, nullptr);
+		stateTracker->bindDescriptorSet(DescriptorSetIndex::Material, materialSet, materialDynOffsets);
+		stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw, perDrawSet, perDrawDynOffsets);
 	}
 
 	// Update tracked state for FSO compatibility

code/graphics/vulkan/VulkanDraw.h

@@ -212,7 +212,7 @@ class VulkanDrawManager {
 		size_t ubo_size,
 		vertex_buffer* buffer,
 		indexed_vertex_source* vert_src,
-		size_t texi) const;
+		size_t texi);
 
 	/**
 	 * @brief Draw a unit sphere with the given material
@@ -286,6 +286,26 @@ class VulkanDrawManager {
 	 */
 	void invalidateGlobalSet() { m_globalSetDirty = true; }
 
+	/**
+	 * @brief Invalidate every memoized descriptor-set cache (Global + Material + PerDraw)
+	 *
+	 * These previous-set caches (see the class comments above m_cachedGlobalSet /
+	 * m_cachedMaterialSet / m_cachedPerDrawSet) assume nothing rebinds a *different*
+	 * descriptor set on the command buffer between applyMaterial() calls behind their
+	 * back. Code that renders directly on the command buffer without going through
+	 * applyMaterial (currently: ImGui's Vulkan backend, drawing into the same active
+	 * composition pass) breaks that assumption -- call this right afterward, alongside
+	 * VulkanStateTracker::invalidateExternalBindings(), so the next applyMaterial() rebuilds
+	 * and rebinds every set instead of trusting stale cached handles.
+	 */
+	void invalidateDrawStateCaches()
+	{
+		m_globalSetDirty = true;
+		m_cachedMaterialValid = false;
+		m_cachedPerDrawValid = false;
+		m_cachedShadowValid = false;
+	}
+
 	/**
 	 * @brief Get current texture addressing mode
 	 */
@@ -449,6 +469,14 @@ class VulkanDrawManager {
 	mutable FrameStats m_frameStats;
 	int m_frameStatsFrameNum = 0;
 
+  public:
+	/**
+	 * @brief Read-only access to this frame's diagnostic counters, e.g. for the ImGui profiler
+	 * overlay's -gr_debug section (see printFrameStats() for the nprintf equivalent)
+	 */
+	const FrameStats& getFrameStats() const { return m_frameStats; }
+
+  private:
 	// First-N debug-log counter for on-demand texture binds; a member rather
 	// than a function-local static so it resets on renderer restart. mutable because
 	// bindMaterialTextures is const. Gates nprintf spam only.
@@ -540,6 +568,41 @@ class VulkanDrawManager {
 	PerDrawSetInputs m_cachedPerDrawInputs;
 	bool m_cachedPerDrawValid = false;
 
+	// ---- Shadow-pass descriptor memoization (renderShadowDraw) ----
+	// The shadow pass doesn't go through applyMaterial, so it gets its own cache.
+	// All three of its sets are constant across the whole pass: the only per-draw
+	// input, the ShadowMapData UBO offset, is a dynamic binding and therefore not
+	// part of the set contents. Reset per frame with the rest (resetFrameStats).
+	struct ShadowSetInputs {
+		int cascadeHandle = -1;
+		vk::DeviceSize cascadeOffset = 0;
+		vk::DeviceSize cascadeSize = 0;
+		bool cascadeValid = false;
+		int shadowDataHandle = -1;
+		size_t shadowDataSize = 0;
+		vk::Buffer transformBuffer = nullptr;
+		size_t transformOffset = 0;
+		size_t transformSize = 0;
+
+		bool operator==(const ShadowSetInputs& o) const
+		{
+			return cascadeHandle == o.cascadeHandle && cascadeOffset == o.cascadeOffset &&
+				   cascadeSize == o.cascadeSize && cascadeValid == o.cascadeValid &&
+				   shadowDataHandle == o.shadowDataHandle && shadowDataSize == o.shadowDataSize &&
+				   transformBuffer == o.transformBuffer && transformOffset == o.transformOffset &&
+				   transformSize == o.transformSize;
+		}
+		bool operator!=(const ShadowSetInputs& o) const
+		{
+			return !(*this == o);
+		}
+	};
+	vk::DescriptorSet m_cachedShadowGlobalSet = nullptr;
+	vk::DescriptorSet m_cachedShadowMaterialSet = nullptr;
+	vk::DescriptorSet m_cachedShadowPerDrawSet = nullptr;
+	ShadowSetInputs m_cachedShadowInputs;
+	bool m_cachedShadowValid = false;
+
 	// Texture overrides for material bindings 4-6.
 	vk::DescriptorImageInfo m_depthTextureInfo; // binding 4: depth/position for soft particles
 	vk::DescriptorImageInfo m_sceneColorInfo;   // binding 5: scene color for distortion

code/graphics/vulkan/VulkanDrawAPI.cpp

@@ -755,12 +755,12 @@ void vulkan_calculate_irrmap()
 		// Set 0: Global (all fallback)
 		vk::DescriptorSet globalSet = descManager->allocateFrameSet(DescriptorSetIndex::Global);
 		Assert(globalSet);
-		writer.writeSet(globalSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Global));
+		writer.writeSet(DescriptorSetIndex::Global, globalSet);
 
 		// Set 1: Material (envmap cubemap at element 0 of texture array)
 		vk::DescriptorSet materialSet = descManager->allocateFrameSet(DescriptorSetIndex::Material);
 		Assert(materialSet);
-		writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+		writer.writeSet(DescriptorSetIndex::Material, materialSet);
 		{
 			std::array<vk::DescriptorImageInfo, VulkanDescriptorManager::MAX_TEXTURE_BINDINGS> texImages;
 			// irrmap-f.sdr declares this binding as samplerCube, so every element needs a cube view
@@ -772,14 +772,14 @@ void vulkan_calculate_irrmap()
 		// Set 2: PerDraw (face UBO at binding 0)
 		vk::DescriptorSet perDrawSet = descManager->allocateFrameSet(DescriptorSetIndex::PerDraw);
 		Assert(perDrawSet);
-		writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+		writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 		writer.setBuffer(PerDrawBinding::GenericData, {faceUBO,
 			static_cast<vk::DeviceSize>(face) * UBO_SLOT_SIZE, UBO_SLOT_SIZE});
 		writer.flush();
 
 		// Bind all descriptor sets
-		cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout,
-			0, {globalSet, materialSet, perDrawSet}, {});
+		const vk::DescriptorSet sets[] = {globalSet, materialSet, perDrawSet};
+		writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Global, sets);
 
 		// Draw fullscreen triangle
 		cmd.draw(3, 1, 0, 0);

code/graphics/vulkan/VulkanMemory.cpp

@@ -140,7 +140,8 @@ VmaMemoryUsage VulkanMemoryManager::toVmaUsage(MemoryUsage usage)
 	}
 }
 
-bool VulkanMemoryManager::allocateBufferMemory(vk::Buffer buffer, MemoryUsage usage, VulkanAllocation& allocation)
+bool VulkanMemoryManager::allocateBufferMemory(vk::Buffer buffer, MemoryUsage usage, VulkanAllocation& allocation,
+	MemoryPurpose purpose)
 {
 	if (!m_initialized) {
 		nprintf(("vulkan", "VulkanMemoryManager::allocateBufferMemory called before initialization!\n"));
@@ -176,14 +177,17 @@ bool VulkanMemoryManager::allocateBufferMemory(vk::Buffer buffer, MemoryUsage us
 
 	allocation.size = allocInfo.size;
 	allocation.mappedPtr = allocInfo.pMappedData;
+	allocation.purpose = purpose;
 
 	++m_allocationCount;
 	m_totalAllocatedBytes += static_cast<size_t>(allocation.size);
+	m_bytesByPurpose[static_cast<size_t>(purpose)] += static_cast<size_t>(allocation.size);
 
 	return true;
 }
 
-bool VulkanMemoryManager::allocateImageMemory(vk::Image image, MemoryUsage usage, VulkanAllocation& allocation)
+bool VulkanMemoryManager::allocateImageMemory(vk::Image image, MemoryUsage usage, VulkanAllocation& allocation,
+	MemoryPurpose purpose)
 {
 	if (!m_initialized) {
 		nprintf(("vulkan", "VulkanMemoryManager::allocateImageMemory called before initialization!\n"));
@@ -219,9 +223,11 @@ bool VulkanMemoryManager::allocateImageMemory(vk::Image image, MemoryUsage usage
 
 	allocation.size = allocInfo.size;
 	allocation.mappedPtr = allocInfo.pMappedData;
+	allocation.purpose = purpose;
 
 	++m_allocationCount;
 	m_totalAllocatedBytes += static_cast<size_t>(allocation.size);
+	m_bytesByPurpose[static_cast<size_t>(purpose)] += static_cast<size_t>(allocation.size);
 
 	return true;
 }
@@ -242,10 +248,12 @@ void VulkanMemoryManager::freeAllocation(VulkanAllocation& allocation)
 
 	--m_allocationCount;
 	m_totalAllocatedBytes -= static_cast<size_t>(allocation.size);
+	m_bytesByPurpose[static_cast<size_t>(allocation.purpose)] -= static_cast<size_t>(allocation.size);
 
 	allocation.vmaAlloc = VK_NULL_HANDLE;
 	allocation.size = 0;
 	allocation.mappedPtr = nullptr;
+	allocation.purpose = MemoryPurpose::Unknown;
 }
 
 void* VulkanMemoryManager::mapMemory(VulkanAllocation& allocation)

code/graphics/vulkan/VulkanMemory.h

@@ -30,6 +30,19 @@ class VulkanRenderer;
 // above in lockstep, or VMA's internal assert will fire.
 constexpr uint32_t VulkanApiVersion = VK_API_VERSION_1_2;
 
+/**
+ * @brief What an allocation is used for, for the profiler overlay's per-purpose GPU memory
+ * breakdown. Unknown covers anything not worth categorizing for that panel (transient staging
+ * buffers, uniform buffers -- the latter are already tracked separately via
+ * UniformBufferManager/gr_debug_stats).
+ */
+enum class MemoryPurpose {
+	Unknown,
+	Texture,
+	Geometry,
+	RenderTarget
+};
+
 /**
  * @brief Memory allocation info returned when allocating GPU memory.
  *
@@ -40,6 +53,7 @@ struct VulkanAllocation {
 	VmaAllocation vmaAlloc = VK_NULL_HANDLE;
 	vk::DeviceSize size = 0;
 	void* mappedPtr = nullptr;  // Non-null if memory is persistently mapped
+	MemoryPurpose purpose = MemoryPurpose::Unknown;
 
 	bool isValid() const { return vmaAlloc != VK_NULL_HANDLE; }
 };
@@ -94,18 +108,24 @@ public:
 	 * @param buffer The buffer to allocate memory for
 	 * @param usage The intended memory usage pattern
 	 * @param[out] allocation Output allocation info
+	 * @param purpose What the buffer is used for, for the per-purpose memory breakdown. Defaults
+	 *        to Unknown for callers that don't care about that breakdown (staging buffers, etc).
 	 * @return true on success
 	 */
-	bool allocateBufferMemory(vk::Buffer buffer, MemoryUsage usage, VulkanAllocation& allocation);
+	bool allocateBufferMemory(vk::Buffer buffer, MemoryUsage usage, VulkanAllocation& allocation,
+		MemoryPurpose purpose = MemoryPurpose::Unknown);
 
 	/**
 	 * @brief Allocate memory for an image
 	 * @param image The image to allocate memory for
 	 * @param usage The intended memory usage pattern
 	 * @param[out] allocation Output allocation info
+	 * @param purpose What the image is used for, for the per-purpose memory breakdown. Defaults
+	 *        to Unknown for callers that don't care about that breakdown.
 	 * @return true on success
 	 */
-	bool allocateImageMemory(vk::Image image, MemoryUsage usage, VulkanAllocation& allocation);
+	bool allocateImageMemory(vk::Image image, MemoryUsage usage, VulkanAllocation& allocation,
+		MemoryPurpose purpose = MemoryPurpose::Unknown);
 
 	/**
 	 * @brief Free a previous allocation
@@ -148,6 +168,10 @@ public:
 	size_t getAllocationCount() const { return m_allocationCount; }
 	size_t getTotalAllocatedBytes() const { return m_totalAllocatedBytes; }
 
+	size_t getTextureBytes() const { return m_bytesByPurpose[static_cast<size_t>(MemoryPurpose::Texture)]; }
+	size_t getGeometryBytes() const { return m_bytesByPurpose[static_cast<size_t>(MemoryPurpose::Geometry)]; }
+	size_t getRenderTargetBytes() const { return m_bytesByPurpose[static_cast<size_t>(MemoryPurpose::RenderTarget)]; }
+
 private:
 	static VmaMemoryUsage toVmaUsage(MemoryUsage usage);
 
@@ -155,6 +179,7 @@ private:
 
 	size_t m_allocationCount = 0;
 	size_t m_totalAllocatedBytes = 0;
+	size_t m_bytesByPurpose[4] = {}; // indexed by MemoryPurpose
 
 	bool m_initialized = false;
 };

code/graphics/vulkan/VulkanPipeline.cpp

@@ -394,9 +394,26 @@ vk::UniquePipeline VulkanPipelineManager::createPipeline(const PipelineConfig& c
 	}
 
 	// Input assembly
+	//
+	// Primitive restart is enabled for every topology that permits it, rather than disabled
+	// outright. Metal always performs primitive restart on indexed draws and cannot turn it off, so
+	// MoltenVK rejects a strip/fan pipeline that asks to disable it -- vkCreateGraphicsPipelines
+	// fails with VK_ERROR_FEATURE_NOT_PRESENT ("Metal does not support disabling primitive
+	// restart"). getPipeline() then returns a null pipeline and the draw is skipped, which on macOS
+	// silently dropped the entire 2D/UI/HUD path (gr_bitmap and friends render quads as
+	// PRIM_TYPE_TRISTRIP; see graphics/render.cpp) while leaving ImGui -- which builds its own
+	// TRIANGLE_LIST pipeline -- as the only thing still on screen.
+	//
+	// Enabling it changes nothing for FSO's geometry: an index buffer is promoted to 32-bit as soon
+	// as a mesh reaches USHRT_MAX vertices (VB_FLAG_LARGE_INDEX, see modelinterp.cpp), so 0xFFFF is
+	// never a real 16-bit index, and 0xFFFFFFFF is unreachable for 32-bit ones. Neither restart
+	// sentinel can collide with live index data.
+	//
+	// List topologies must keep it disabled: the spec only allows primitiveRestartEnable on them
+	// with VK_EXT_primitive_topology_list_restart, which FSO does not request.
 	vk::PipelineInputAssemblyStateCreateInfo inputAssembly;
 	inputAssembly.topology = convertPrimitiveType(config.primitiveType);
-	inputAssembly.primitiveRestartEnable = VK_FALSE;
+	inputAssembly.primitiveRestartEnable = topologySupportsPrimitiveRestart(inputAssembly.topology);
 
 	// Viewport state (dynamic)
 	vk::PipelineViewportStateCreateInfo viewportState;

code/graphics/vulkan/VulkanPostProcessing.cpp

@@ -687,7 +687,7 @@ void VulkanPostProcessor::blitToSwapChain(vk::CommandBuffer cmd)
 	// Set 1: Material — source texture at array slot 0
 	vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 	Assert(materialSet);
-	writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+	writer.writeSet(DescriptorSetIndex::Material, materialSet);
 	{
 		std::array<vk::DescriptorImageInfo, VulkanDescriptorManager::MAX_TEXTURE_BINDINGS> texArrayInfos;
 		texArrayInfos.fill(descriptorMgr->getFallbacks().texture2D);
@@ -701,7 +701,7 @@ void VulkanPostProcessor::blitToSwapChain(vk::CommandBuffer cmd)
 	// Set 2: PerDraw — tonemapping UBO (from the per-frame scratch ring)
 	vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 	Assert(perDrawSet);
-	writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+	writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 
 	// LDR path: passthrough (tonemapping already ran). Fallback path: live
 	// parameters from the engine lighting profile.
@@ -732,8 +732,12 @@ void VulkanPostProcessor::blitToSwapChain(vk::CommandBuffer cmd)
 			{m_ctx.scratchRing.buffer(), slotOffset, m_ctx.scratchRing.slotSize()});
 	}
 	writer.flush();
-	stateTracker->bindDescriptorSet(DescriptorSetIndex::Material, materialSet);
-	stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw, perDrawSet);
+	stateTracker->bindDescriptorSet(DescriptorSetIndex::Material,
+		materialSet,
+		writer.dynamicOffsets(DescriptorSetIndex::Material));
+	stateTracker->bindDescriptorSet(DescriptorSetIndex::PerDraw,
+		perDrawSet,
+		writer.dynamicOffsets(DescriptorSetIndex::PerDraw));
 
 	// Draw fullscreen triangle (3 vertices from gl_VertexIndex, no vertex buffer)
 	cmd.draw(3, 1, 0, 0);
@@ -800,7 +804,7 @@ void VulkanPostProcessor::encodeToSwapChainPass(vk::CommandBuffer cmd, vk::Rende
 
 	vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 	Assert(materialSet);
-	writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+	writer.writeSet(DescriptorSetIndex::Material, materialSet);
 	{
 		std::array<vk::DescriptorImageInfo, VulkanDescriptorManager::MAX_TEXTURE_BINDINGS> texArrayInfos;
 		texArrayInfos.fill(descriptorMgr->getFallbacks().texture2D);
@@ -811,7 +815,7 @@ void VulkanPostProcessor::encodeToSwapChainPass(vk::CommandBuffer cmd, vk::Rende
 
 	vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 	Assert(perDrawSet);
-	writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+	writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 	{
 		vk::DeviceSize slotOffset =
 			m_ctx.scratchRing.alloc(descriptorMgr->getCurrentFrame(), uboData, uboSize);
@@ -820,9 +824,8 @@ void VulkanPostProcessor::encodeToSwapChainPass(vk::CommandBuffer cmd, vk::Rende
 	}
 	writer.flush();
 
-	cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout,
-		static_cast<uint32_t>(DescriptorSetIndex::Material),
-		{materialSet, perDrawSet}, {});
+	const vk::DescriptorSet sets[] = {materialSet, perDrawSet};
+	writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Material, sets);
 
 	cmd.draw(3, 1, 0, 0);
 	cmd.endRenderPass();

code/graphics/vulkan/VulkanPostProcessing.h

@@ -204,6 +204,7 @@ public:
 	vk::ImageView depthView() const { return m_depth.view; }
 	vk::Image depthImage() const { return m_depth.image; }
 	vk::Sampler compareSampler() const { return m_compareSampler; }
+	vk::Sampler rawSampler() const { return m_rawSampler; }
 	vk::RenderPass renderPass() const { return m_renderPass; }
 	vk::Framebuffer framebuffer() const { return m_framebuffer; }
 
@@ -211,6 +212,7 @@ private:
 	PostProcessContext* m_ctx = nullptr;
 	RenderTarget m_depth;   // D32F, 2D array (Num_shadow_cascades + Num_cockpit_shadow_cascades layers)
 	vk::Sampler m_compareSampler; // Depth-compare sampler for hardware PCF (sampler2DArrayShadow)
+	vk::Sampler m_rawSampler;     // Non-compare sampler on the same view, for PCSS blocker search
 	vk::RenderPass m_renderPass;
 	vk::Framebuffer m_framebuffer;
 	int m_textureSize = 0;
@@ -1111,6 +1113,16 @@ public:
 		return {m_shadow.compareSampler(), m_shadow.depthView(), vk::ImageLayout::eShaderReadOnlyOptimal};
 	}
 
+	/**
+	 * @brief Get a ready-to-use DescriptorImageInfo for raw (uncompared) shadow map reads
+	 *
+	 * Same image view as getShadowTextureInfo(), but with compare mode off, for the PCSS
+	 * blocker search (which needs actual depth values, not a compare result).
+	 */
+	vk::DescriptorImageInfo getShadowRawTextureInfo() const {
+		return {m_shadow.rawSampler(), m_shadow.depthView(), vk::ImageLayout::eShaderReadOnlyOptimal};
+	}
+
 	// ========== Fog / Volumetric Nebula ==========
 
 	/**

code/graphics/vulkan/VulkanPostProcessingBloom.cpp

@@ -170,7 +170,8 @@ bool VulkanBloom::createTargets()
 			return false;
 		}
 
-		if (!m_ctx->memoryManager->allocateImageMemory(m_tex[i].image, MemoryUsage::GpuOnly, m_tex[i].allocation)) {
+		if (!m_ctx->memoryManager->allocateImageMemory(
+				m_tex[i].image, MemoryUsage::GpuOnly, m_tex[i].allocation, MemoryPurpose::RenderTarget)) {
 			nprintf(("vulkan", "VulkanBloom: Failed to allocate bloom image %zu memory!\n", i));
 			return false;
 		}

code/graphics/vulkan/VulkanPostProcessingCommon.cpp

@@ -176,13 +176,13 @@ void PostProcessContext::drawFullscreenTriangle(vk::CommandBuffer cmd, vk::Rende
 	if (bindGlobalSet) {
 		globalSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Global);
 		Assert(globalSet);
-		writer.writeSet(globalSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Global));
+		writer.writeSet(DescriptorSetIndex::Global, globalSet);
 	}
 
 	// Set 1: Material
 	vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 	Assert(materialSet);
-	writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+	writer.writeSet(DescriptorSetIndex::Material, materialSet);
 	{
 		std::array<vk::DescriptorImageInfo, VulkanDescriptorManager::MAX_TEXTURE_BINDINGS> texArrayInfos;
 		texArrayInfos.fill(descriptorMgr->getFallbacks().texture2D);
@@ -194,7 +194,7 @@ void PostProcessContext::drawFullscreenTriangle(vk::CommandBuffer cmd, vk::Rende
 	// Set 2: PerDraw
 	vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 	Assert(perDrawSet);
-	writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+	writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 	if (uboData != nullptr && uboSize > 0 && scratchRing.isValid()) {
 		vk::DeviceSize slotOffset = scratchRing.alloc(descriptorMgr->getCurrentFrame(), uboData, uboSize);
 		writer.setBuffer(PerDrawBinding::GenericData, {scratchRing.buffer(), slotOffset, scratchRing.slotSize()});
@@ -205,13 +205,11 @@ void PostProcessContext::drawFullscreenTriangle(vk::CommandBuffer cmd, vk::Rende
 	// contiguous (0,1,2), so when Global is (re)bound here it and Material/PerDraw
 	// go in one call; otherwise Set 0 is left as whatever frame setup bound.
 	if (bindGlobalSet) {
-		cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout,
-			static_cast<uint32_t>(DescriptorSetIndex::Global),
-			{globalSet, materialSet, perDrawSet}, {});
+		const vk::DescriptorSet sets[] = {globalSet, materialSet, perDrawSet};
+		writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Global, sets);
 	} else {
-		cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout,
-			static_cast<uint32_t>(DescriptorSetIndex::Material),
-			{materialSet, perDrawSet}, {});
+		const vk::DescriptorSet sets[] = {materialSet, perDrawSet};
+		writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Material, sets);
 	}
 
 	cmd.draw(3, 1, 0, 0);
@@ -281,7 +279,7 @@ void PostProcessContext::drawFullscreenTriangleMulti(vk::CommandBuffer cmd, vk::
 
 	vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 	Assert(materialSet);
-	writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+	writer.writeSet(DescriptorSetIndex::Material, materialSet);
 	{
 		std::array<vk::DescriptorImageInfo, VulkanDescriptorManager::MAX_TEXTURE_BINDINGS> texArrayInfos;
 		texArrayInfos.fill(descriptorMgr->getFallbacks().texture2D);
@@ -293,16 +291,15 @@ void PostProcessContext::drawFullscreenTriangleMulti(vk::CommandBuffer cmd, vk::
 
 	vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 	Assert(perDrawSet);
-	writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+	writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 	if (uboData != nullptr && uboSize > 0 && scratchRing.isValid()) {
 		vk::DeviceSize slotOffset = scratchRing.alloc(descriptorMgr->getCurrentFrame(), uboData, uboSize);
 		writer.setBuffer(PerDrawBinding::GenericData, {scratchRing.buffer(), slotOffset, scratchRing.slotSize()});
 	}
 	writer.flush();
 
-	cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout,
-		static_cast<uint32_t>(DescriptorSetIndex::Material),
-		{materialSet, perDrawSet}, {});
+	const vk::DescriptorSet sets[] = {materialSet, perDrawSet};
+	writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Material, sets);
 
 	cmd.draw(3, 1, 0, 0);
 	cmd.endRenderPass();
@@ -337,7 +334,7 @@ bool PostProcessContext::createImage(uint32_t width, uint32_t height, vk::Format
 	}
 
 	// Allocate memory
-	if (!memoryManager->allocateImageMemory(outImage, MemoryUsage::GpuOnly, outAllocation)) {
+	if (!memoryManager->allocateImageMemory(outImage, MemoryUsage::GpuOnly, outAllocation, MemoryPurpose::RenderTarget)) {
 		nprintf(("vulkan", "VulkanPostProcessor: Failed to allocate image memory!\n"));
 		device.destroyImage(outImage);
 		outImage = nullptr;

code/graphics/vulkan/VulkanPostProcessingFog.cpp

@@ -304,7 +304,7 @@ void VulkanFog::renderScene(vk::CommandBuffer cmd)
 	// Set 1: Material
 	vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 	Assert(materialSet);
-	writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+	writer.writeSet(DescriptorSetIndex::Material, materialSet);
 	{
 		std::array<vk::DescriptorImageInfo, VulkanDescriptorManager::MAX_TEXTURE_BINDINGS> texArrayInfos;
 		texArrayInfos.fill(descriptorMgr->getFallbacks().texture2D);
@@ -316,7 +316,7 @@ void VulkanFog::renderScene(vk::CommandBuffer cmd)
 	// Set 2: PerDraw — fog UBO (from the per-frame scratch ring)
 	vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 	Assert(perDrawSet);
-	writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+	writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 	{
 		vk::DeviceSize slotOffset =
 			m_ctx->scratchRing.alloc(descriptorMgr->getCurrentFrame(), &fogData, sizeof(fogData));
@@ -326,9 +326,8 @@ void VulkanFog::renderScene(vk::CommandBuffer cmd)
 	writer.flush();
 
 	// Bind descriptor sets and draw
-	cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout,
-		static_cast<uint32_t>(DescriptorSetIndex::Material),
-		{materialSet, perDrawSet}, {});
+	const vk::DescriptorSet sets[] = {materialSet, perDrawSet};
+	writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Material, sets);
 
 	cmd.draw(3, 1, 0, 0);
 	cmd.endRenderPass();
@@ -420,7 +419,8 @@ void VulkanFog::renderVolumetric(vk::CommandBuffer cmd)
 			return;
 		}
 
-		Verification(m_ctx->memoryManager->allocateImageMemory(m_emissiveMipmapped.image, MemoryUsage::GpuOnly, m_emissiveMipmapped.allocation),
+		Verification(m_ctx->memoryManager->allocateImageMemory(m_emissiveMipmapped.image, MemoryUsage::GpuOnly,
+			m_emissiveMipmapped.allocation, MemoryPurpose::RenderTarget),
 			"Failed to allocate memory for mipmapped emissive image");
 
 		// Create full-mip-chain view for LOD sampling
@@ -614,7 +614,7 @@ void VulkanFog::renderVolumetric(vk::CommandBuffer cmd)
 	// Set 1: Material
 	vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 	Assert(materialSet);
-	writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+	writer.writeSet(DescriptorSetIndex::Material, materialSet);
 	{
 		std::array<vk::DescriptorImageInfo, VulkanDescriptorManager::MAX_TEXTURE_BINDINGS> texArrayInfos;
 		texArrayInfos.fill(descriptorMgr->getFallbacks().texture2D);
@@ -638,7 +638,7 @@ void VulkanFog::renderVolumetric(vk::CommandBuffer cmd)
 	// Set 2: PerDraw — volumetric fog UBO (from the per-frame scratch ring)
 	vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 	Assert(perDrawSet);
-	writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+	writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 	{
 		vk::DeviceSize slotOffset =
 			m_ctx->scratchRing.alloc(descriptorMgr->getCurrentFrame(), &volData, sizeof(volData));
@@ -648,9 +648,8 @@ void VulkanFog::renderVolumetric(vk::CommandBuffer cmd)
 	writer.flush();
 
 	// Bind descriptor sets and draw
-	cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout,
-		static_cast<uint32_t>(DescriptorSetIndex::Material),
-		{materialSet, perDrawSet}, {});
+	const vk::DescriptorSet sets[] = {materialSet, perDrawSet};
+	writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Material, sets);
 
 	cmd.draw(3, 1, 0, 0);
 	cmd.endRenderPass();

code/graphics/vulkan/VulkanPostProcessingLighting.cpp

@@ -13,6 +13,7 @@
 #include "graphics/grinternal.h"
 #include "graphics/light.h"
 #include "graphics/matrix.h"
+#include "graphics/rtao.h"
 #include "graphics/shadows.h"
 #include "graphics/2d.h"
 #include "bmpman/bmpman.h"
@@ -70,7 +71,8 @@ bool VulkanDeferredLighting::initLightVolumes()
 			return false;
 		}
 
-		if (!m_ctx->memoryManager->allocateBufferMemory(m_sphereMesh.vbo, MemoryUsage::CpuToGpu, m_sphereMesh.vboAlloc)) {
+		if (!m_ctx->memoryManager->allocateBufferMemory(
+				m_sphereMesh.vbo, MemoryUsage::CpuToGpu, m_sphereMesh.vboAlloc, MemoryPurpose::Geometry)) {
 			m_ctx->device.destroyBuffer(m_sphereMesh.vbo);
 			m_sphereMesh.vbo = nullptr;
 			return false;
@@ -95,7 +97,8 @@ bool VulkanDeferredLighting::initLightVolumes()
 			return false;
 		}
 
-		if (!m_ctx->memoryManager->allocateBufferMemory(m_sphereMesh.ibo, MemoryUsage::CpuToGpu, m_sphereMesh.iboAlloc)) {
+		if (!m_ctx->memoryManager->allocateBufferMemory(
+				m_sphereMesh.ibo, MemoryUsage::CpuToGpu, m_sphereMesh.iboAlloc, MemoryPurpose::Geometry)) {
 			m_ctx->device.destroyBuffer(m_sphereMesh.ibo);
 			m_sphereMesh.ibo = nullptr;
 			return false;
@@ -126,7 +129,8 @@ bool VulkanDeferredLighting::initLightVolumes()
 			return false;
 		}
 
-		if (!m_ctx->memoryManager->allocateBufferMemory(m_cylinderMesh.vbo, MemoryUsage::CpuToGpu, m_cylinderMesh.vboAlloc)) {
+		if (!m_ctx->memoryManager->allocateBufferMemory(
+				m_cylinderMesh.vbo, MemoryUsage::CpuToGpu, m_cylinderMesh.vboAlloc, MemoryPurpose::Geometry)) {
 			m_ctx->device.destroyBuffer(m_cylinderMesh.vbo);
 			m_cylinderMesh.vbo = nullptr;
 			return false;
@@ -150,7 +154,8 @@ bool VulkanDeferredLighting::initLightVolumes()
 			return false;
 		}
 
-		if (!m_ctx->memoryManager->allocateBufferMemory(m_cylinderMesh.ibo, MemoryUsage::CpuToGpu, m_cylinderMesh.iboAlloc)) {
+		if (!m_ctx->memoryManager->allocateBufferMemory(
+				m_cylinderMesh.ibo, MemoryUsage::CpuToGpu, m_cylinderMesh.iboAlloc, MemoryPurpose::Geometry)) {
 			m_ctx->device.destroyBuffer(m_cylinderMesh.ibo);
 			m_cylinderMesh.ibo = nullptr;
 			return false;
@@ -502,8 +507,12 @@ void VulkanDeferredLighting::render(vk::CommandBuffer cmd)
 	{
 		auto* header = reinterpret_cast<graphics::deferred_global_data*>(uboMapped + regionBase);
 		memset(header, 0, sizeof(graphics::deferred_global_data));
-		header->invScreenWidth = 1.0f / gr_screen.max_w;
-		header->invScreenHeight = 1.0f / gr_screen.max_h;
+		// Same as the OpenGL backend: deferred-f.sdr normalizes gl_FragCoord against these to
+		// sample the G-buffer, so they must describe the G-buffer, not gr_screen. resize() keeps
+		// sceneExtent equal to gr_screen today, which is why deriving it from the extent is a
+		// no-op here -- but it states the actual requirement instead of relying on that.
+		header->invScreenWidth = 1.0f / static_cast<float>(m_ctx->sceneExtent.width);
+		header->invScreenHeight = 1.0f / static_cast<float>(m_ctx->sceneExtent.height);
 		header->nearPlane = gr_near_plane;
 
 		if (m_shadow->isInitialized() && Shadow_quality != ShadowQuality::Disabled) {
@@ -683,6 +692,9 @@ void VulkanDeferredLighting::render(vk::CommandBuffer cmd)
 	if (rtShadowsActive) {
 		lightShaderFlags |= SDR_FLAG_DEFERRED_RT_SHADOWS;
 	}
+	if (rtao_enabled()) {
+		lightShaderFlags |= SDR_FLAG_DEFERRED_RTAO;
+	}
 	if (envMapAvailable) {
 		lightShaderFlags |= SDR_FLAG_ENV_MAP;
 	}
@@ -750,8 +762,10 @@ void VulkanDeferredLighting::render(vk::CommandBuffer cmd)
 	// Shadow map is depth-only, sampled with a depth-compare sampler
 	// (sampler2DArrayShadow) for hardware PCF.
 	vk::DescriptorImageInfo shadowTexInfo;
+	vk::DescriptorImageInfo shadowRawTexInfo;
 	if (m_shadow->isInitialized() && m_shadow->depthView()) {
 		shadowTexInfo = {m_shadow->compareSampler(), m_shadow->depthView(), vk::ImageLayout::eShaderReadOnlyOptimal};
+		shadowRawTexInfo = {m_shadow->rawSampler(), m_shadow->depthView(), vk::ImageLayout::eShaderReadOnlyOptimal};
 	}
 
 	// Shadow cascade params (projection matrices/distances) are bound per-frame via
@@ -788,7 +802,7 @@ void VulkanDeferredLighting::render(vk::CommandBuffer cmd)
 		// Set 0: Global
 		vk::DescriptorSet globalSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Global);
 		if (!globalSet) return false;
-		writer.writeSet(globalSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Global));
+		writer.writeSet(DescriptorSetIndex::Global, globalSet);
 		writer.setBuffer(GlobalBinding::Lights, {m_deferredUBO,
 			lightDataOffset + (li * lightDataSize), sizeof(graphics::deferred_light_data)});
 		writer.setBuffer(GlobalBinding::DeferredData, {m_deferredUBO,
@@ -797,23 +811,24 @@ void VulkanDeferredLighting::render(vk::CommandBuffer cmd)
 		writer.setImage(GlobalBinding::EnvMap, envTexInfo);
 		writer.setImage(GlobalBinding::IrradianceMap, irrTexInfo);
 		writer.setBuffer(GlobalBinding::ShadowCascadeParams, shadowCascadeParamsInfo);
+		writer.setImage(GlobalBinding::ShadowMapRaw, shadowRawTexInfo);
 
 		// Set 1: Material
 		vk::DescriptorSet materialSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::Material);
 		if (!materialSet) return false;
-		writer.writeSet(materialSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::Material));
+		writer.writeSet(DescriptorSetIndex::Material, materialSet);
 		writer.setImageArray(MaterialBinding::TextureArray, gbufTexArray);
 
 		// Set 2: PerDraw
 		vk::DescriptorSet perDrawSet = descriptorMgr->allocateFrameSet(DescriptorSetIndex::PerDraw);
 		if (!perDrawSet) return false;
-		writer.writeSet(perDrawSet, VulkanDescriptorManager::getSetTemplate(DescriptorSetIndex::PerDraw));
+		writer.writeSet(DescriptorSetIndex::PerDraw, perDrawSet);
 		writer.setBuffer(PerDrawBinding::Matrices, {m_deferredUBO,
 			matrixDataOffset + (li * matrixDataSize), sizeof(graphics::matrix_uniforms)});
 		writer.flush();
 
-		std::array<vk::DescriptorSet, 3> sets = { globalSet, materialSet, perDrawSet };
-		cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout, 0, sets, {});
+		const vk::DescriptorSet sets[] = {globalSet, materialSet, perDrawSet};
+		writer.bindSets(cmd, pipelineLayout, DescriptorSetIndex::Global, sets);
 
 		return true;
 	};

code/graphics/vulkan/VulkanPostProcessingMSAA.cpp

@@ -206,7 +206,8 @@ bool VulkanDeferredGBuffer::createMsaaTargets()
 			return false;
 		}
 
-		if (!m_ctx->memoryManager->allocateImageMemory(m_msaaDepthImage, MemoryUsage::GpuOnly, m_msaaDepthAlloc)) {
+		if (!m_ctx->memoryManager->allocateImageMemory(
+				m_msaaDepthImage, MemoryUsage::GpuOnly, m_msaaDepthAlloc, MemoryPurpose::RenderTarget)) {
 			nprintf(("vulkan", "VulkanPostProcessor: Failed to allocate MSAA depth memory!\n"));
 			m_ctx->device.destroyImage(m_msaaDepthImage);
 			m_msaaDepthImage = nullptr;

code/graphics/vulkan/VulkanPostProcessingShadow.cpp

@@ -34,14 +34,7 @@ bool VulkanShadowMap::init(PostProcessContext& ctx)
 		return false;
 	}
 
-	int size;
-	switch (Shadow_quality) {
-	case ShadowQuality::Low:    size = 512; break;
-	case ShadowQuality::Medium: size = 1024; break;
-	case ShadowQuality::High:   size = 2048; break;
-	case ShadowQuality::Ultra:  size = 4096; break;
-	default:                    size = 512; break;
-	}
+	const int size = shadows_map_resolution();
 
 	const auto layers = static_cast<uint32_t>(Num_shadow_cascades + Num_cockpit_shadow_cascades);
 	nprintf(("vulkan", "VulkanPostProcessor: Creating %dx%d shadow map (%d cascades)\n", size, size, layers));
@@ -70,7 +63,8 @@ bool VulkanShadowMap::init(PostProcessContext& ctx)
 			return false;
 		}
 
-		if (!m_ctx->memoryManager->allocateImageMemory(m_depth.image, MemoryUsage::GpuOnly, m_depth.allocation)) {
+		if (!m_ctx->memoryManager->allocateImageMemory(
+				m_depth.image, MemoryUsage::GpuOnly, m_depth.allocation, MemoryPurpose::RenderTarget)) {
 			m_ctx->device.destroyImage(m_depth.image);
 			m_depth.image = nullptr;
 			return false;
@@ -187,6 +181,32 @@ bool VulkanShadowMap::init(PostProcessContext& ctx)
 		}
 	}
 
+	// Raw (non-compare) sampler on the same depth view, for the PCSS blocker search --
+	// it needs actual stored depth values, not a compare result. GL_NEAREST-equivalent
+	// filtering: the blocker search wants the exact per-texel depth, not a hardware-
+	// filtered blend across the compare boundary (deliberately different from the compare
+	// sampler's linear filtering above). Vulkan samplers are independent of images, so this
+	// is always available -- no capability gate needed here (contrast the OpenGL backend,
+	// which needs GL 3.3 because compare mode there is texture-object state).
+	{
+		vk::SamplerCreateInfo samplerInfo;
+		samplerInfo.magFilter = vk::Filter::eNearest;
+		samplerInfo.minFilter = vk::Filter::eNearest;
+		samplerInfo.mipmapMode = vk::SamplerMipmapMode::eNearest;
+		samplerInfo.addressModeU = vk::SamplerAddressMode::eClampToEdge;
+		samplerInfo.addressModeV = vk::SamplerAddressMode::eClampToEdge;
+		samplerInfo.addressModeW = vk::SamplerAddressMode::eClampToEdge;
+		samplerInfo.compareEnable = VK_FALSE;
+		samplerInfo.borderColor = vk::BorderColor::eFloatOpaqueWhite;
+
+		try {
+			m_rawSampler = m_ctx->device.createSampler(samplerInfo);
+		} catch (const vk::SystemError& e) {
+			nprintf(("vulkan", "VulkanPostProcessor: Failed to create shadow raw sampler: %s\n", e.what()));
+			return false;
+		}
+	}
+
 	m_textureSize = size;
 	m_initialized = true;
 	nprintf(("vulkan", "VulkanPostProcessor: Shadow map initialized (%dx%d, %d cascades)\n", size, size, layers));
@@ -203,6 +223,10 @@ void VulkanShadowMap::shutdown()
 		m_ctx->device.destroySampler(m_compareSampler);
 		m_compareSampler = nullptr;
 	}
+	if (m_rawSampler) {
+		m_ctx->device.destroySampler(m_rawSampler);
+		m_rawSampler = nullptr;
+	}
 	if (m_framebuffer) {
 		m_ctx->device.destroyFramebuffer(m_framebuffer);
 		m_framebuffer = nullptr;

code/graphics/vulkan/VulkanRaytracing.h

@@ -275,6 +275,10 @@ private:
 	// gated behind m_enabled/m_initialized so this only matters defensively.
 	uint32_t currentFrameIndex() const { return m_bufferManager != nullptr ? m_bufferManager->getCurrentFrame() : 0; }
 
+	// Monotonic frame number of the last buildTlas() that actually ran, for the
+	// per-frame idempotence guard (multiple callers may request a TLAS per frame).
+	uint64_t m_lastTlasBuildFrame = UINT64_MAX;
+
 	vk::Device m_device;
 	vk::PhysicalDevice m_physicalDevice;
 	VulkanMemoryManager* m_memoryManager = nullptr;

code/graphics/vulkan/VulkanRaytracingTlas.cpp

@@ -425,6 +425,16 @@ void VulkanRaytracingManager::buildTlas()
 		return;
 	}
 
+	// Idempotence guard: both the shadow path (shadows_render_all ->
+	// gr_build_shadow_tlas) and the RTAO fallback trigger
+	// (vulkan_deferred_lighting_finish, for when shadow rendering is disabled)
+	// may request a TLAS in the same frame -- only the first request builds.
+	const uint64_t frameNumber = m_bufferManager->getCurrentFrameNumber();
+	if (m_lastTlasBuildFrame == frameNumber) {
+		return;
+	}
+	m_lastTlasBuildFrame = frameNumber;
+
 	// Each frame-in-flight slot owns its own instance/TLAS/scratch buffers (see
 	// FrameTlasResources' declaration for why a single shared set would race
 	// across overlapping in-flight frames).

code/graphics/vulkan/VulkanRenderer.cpp

@@ -63,7 +63,7 @@ void VulkanRenderer::createCompositionResources()
 		auto image = m_device->createImageUnique(imageInfo);
 
 		VulkanAllocation alloc{};
-		m_memoryManager->allocateImageMemory(image.get(), MemoryUsage::GpuOnly, alloc);
+		m_memoryManager->allocateImageMemory(image.get(), MemoryUsage::GpuOnly, alloc, MemoryPurpose::RenderTarget);
 
 		vk::ImageViewCreateInfo viewInfo;
 		viewInfo.image = image.get();
@@ -279,7 +279,8 @@ void VulkanRenderer::createDepthResources()
 	m_depthImage = m_device->createImageUnique(imageInfo);
 
 	// Allocate GPU memory for the depth image
-	m_memoryManager->allocateImageMemory(m_depthImage.get(), MemoryUsage::GpuOnly, m_depthImageMemory);
+	m_memoryManager->allocateImageMemory(
+		m_depthImage.get(), MemoryUsage::GpuOnly, m_depthImageMemory, MemoryPurpose::RenderTarget);
 
 	// Create depth image view
 	vk::ImageViewCreateInfo viewInfo;

code/graphics/vulkan/VulkanRendererSetup.cpp

@@ -947,6 +947,15 @@ bool VulkanRenderer::createLogicalDevice(const PhysicalDeviceValues& deviceValue
 			enabledExtensions.push_back(VK_EXT_HDR_METADATA_EXTENSION_NAME);
 			mprintf(("Vulkan: Enabling %s (HDR10 metadata)\n", VK_EXT_HDR_METADATA_EXTENSION_NAME));
 		}
+		// Required by the Vulkan Portability subset whenever the physical device
+		// advertises it (MoltenVK / macOS). Creating a device without it is
+		// undefined behavior and trips VUID-VkDeviceCreateInfo-pProperties-04451.
+		// The extension-name macro lives in vulkan_beta.h (VK_ENABLE_BETA_EXTENSIONS);
+		// our headers do not enable that, so use the literal string instead.
+		if (strcmp(ext.extensionName, "VK_KHR_portability_subset") == 0) {
+			enabledExtensions.push_back("VK_KHR_portability_subset");
+			mprintf(("Vulkan: Enabling VK_KHR_portability_subset\n"));
+		}
 		if (strcmp(ext.extensionName, VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME) == 0) {
 			hasAccelerationStructureExt = true;
 		}

code/graphics/vulkan/VulkanState.cpp

@@ -251,25 +251,47 @@ void VulkanStateTracker::bindPipeline(vk::Pipeline pipeline, vk::PipelineLayout
 	}
 }
 
-void VulkanStateTracker::bindDescriptorSet(DescriptorSetIndex setIndex, vk::DescriptorSet set,
-                                            const SCP_vector<uint32_t>& dynamicOffsets)
+void VulkanStateTracker::bindDescriptorSet(DescriptorSetIndex setIndex,
+	vk::DescriptorSet set,
+	const uint32_t* dynamicOffsets)
 {
 	Assertion(m_cmdBuffer, "bindDescriptorSet called without active command buffer!");
 	Assertion(m_currentPipelineLayout, "bindDescriptorSet called without bound pipeline layout!");
 	Assertion(set, "bindDescriptorSet called with null descriptor set!");
 
 	auto index = static_cast<uint32_t>(setIndex);
+	const uint32_t dynCount = VulkanDescriptorManager::getDynamicOffsetCount(setIndex);
+	Assertion(dynCount == 0 || dynamicOffsets != nullptr,
+		"bindDescriptorSet: set %u declares %u dynamic descriptors but no offsets were supplied!",
+		index,
+		dynCount);
 
-	if (m_boundDescriptorSets[index] != set) {
-		m_cmdBuffer.bindDescriptorSets(
-			vk::PipelineBindPoint::eGraphics,
+	// The redundancy check has to cover the dynamic offsets too, not just the set
+	// handle: with dynamic UBOs the common case is the *same* set rebound with a new
+	// offset every draw, and skipping that bind would silently feed every draw the
+	// previous draw's uniforms.
+	auto& boundDyn = m_boundDynamicOffsets[index];
+	bool offsetsChanged = false;
+	for (uint32_t i = 0; i < dynCount; ++i) {
+		if (boundDyn[i] != dynamicOffsets[i]) {
+			offsetsChanged = true;
+			break;
+		}
+	}
+
+	if (m_boundDescriptorSets[index] != set || offsetsChanged) {
+		m_cmdBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
 			m_currentPipelineLayout,
 			index,
-			1, &set,
-			static_cast<uint32_t>(dynamicOffsets.size()),
-			dynamicOffsets.empty() ? nullptr : dynamicOffsets.data());
+			1,
+			&set,
+			dynCount,
+			dynCount > 0 ? dynamicOffsets : nullptr);
 
 		m_boundDescriptorSets[index] = set;
+		for (uint32_t i = 0; i < dynCount; ++i) {
+			boundDyn[i] = dynamicOffsets[i];
+		}
 	}
 }
 

code/graphics/vulkan/VulkanState.h

@@ -134,10 +134,15 @@ class VulkanStateTracker {
 
 	/**
 	 * @brief Bind descriptor set
+	 *
+	 * @param dynamicOffsets Offsets for the set layout's eUniformBufferDynamic
+	 *        bindings, ordered by binding number. Must point to at least
+	 *        VulkanDescriptorManager::getDynamicOffsetCount(setIndex) entries
+	 *        (DescriptorWriter::dynamicOffsets() produces exactly that); may be
+	 *        null only for a set that declares none.
 	 */
-	void bindDescriptorSet(DescriptorSetIndex setIndex,
-		vk::DescriptorSet set,
-		const SCP_vector<uint32_t>& dynamicOffsets = {});
+	void
+	bindDescriptorSet(DescriptorSetIndex setIndex, vk::DescriptorSet set, const uint32_t* dynamicOffsets);
 
 	// ========== Buffer Binding ==========
 
@@ -312,6 +317,11 @@ class VulkanStateTracker {
 
 	// Descriptor sets
 	std::array<vk::DescriptorSet, static_cast<size_t>(DescriptorSetIndex::Count)> m_boundDescriptorSets;
+	// Dynamic offsets the currently-bound set was bound with, so an offset-only
+	// change still forces a rebind (see bindDescriptorSet).
+	std::array<std::array<uint32_t, DescriptorWriter::MAX_DYNAMIC_OFFSETS_PER_SET>,
+		static_cast<size_t>(DescriptorSetIndex::Count)>
+		m_boundDynamicOffsets{};
 
 	// Dynamic state
 	vk::Viewport m_viewport;

code/graphics/vulkan/VulkanTexture.cpp

@@ -2528,7 +2528,7 @@ bool VulkanTextureManager::createImage(uint32_t width, uint32_t height, uint32_t
 		return false;
 	}
 
-	if (!m_memoryManager->allocateImageMemory(image, memUsage, allocation)) {
+	if (!m_memoryManager->allocateImageMemory(image, memUsage, allocation, MemoryPurpose::Texture)) {
 		m_device.destroyImage(image);
 		image = nullptr;
 		return false;

code/graphics/vulkan/gr_vulkan.cpp

@@ -75,32 +75,6 @@ void vulkan_model_unloaded(int pm_id)
 	}
 }
 
-void vulkan_build_shadow_tlas()
-{
-	if (auto* rt = getRaytracingManager()) {
-		// vkCmdBuildAccelerationStructuresKHR (and the memory barrier that follows
-		// it in buildTlas()) must be recorded outside any render pass instance.
-		// This is called once per frame, before the shadow map render pass begins,
-		// while the previous render pass (G-buffer/scene) is typically still
-		// active -- end it here. vulkan_shadow_map_start()'s first_pass branch
-		// skips its own endRenderPass() call when it finds none active.
-		auto* stateTracker = getStateTracker();
-		if (stateTracker->getCurrentRenderPass()) {
-			stateTracker->getCommandBuffer().endRenderPass();
-			stateTracker->setRenderPass(vk::RenderPass());
-		}
-
-		rt->buildTlas();
-		// Refresh the Global set's live TLAS fallback so every writeSet(Global)
-		// this frame picks up the freshly built TLAS automatically -- see
-		// DescriptorFallbacks::shadowTlas.
-		getDescriptorManager()->setCurrentShadowTlas(rt->getTlasForShaderBinding());
-		// The memoized per-frame Global set (VulkanDrawManager) must rebuild so the
-		// new TLAS reaches subsequent draws' Set 0 instead of a cached stale one.
-		getDrawManager()->invalidateGlobalSet();
-	}
-}
-
 bool vulkan_is_capable(gr_capability capability)
 {
 	switch (capability) {
@@ -162,6 +136,10 @@ bool vulkan_is_capable(gr_capability capability)
 		return false;
 	case gr_capability::CAPABILITY_RAYTRACED_SHADOWS:
 		return getRendererInstance()->supportsRaytracedShadows();
+	case gr_capability::CAPABILITY_SHADOW_CONTACT_HARDENING:
+		// Vulkan samplers are independent of images, so a second (non-compare) sampler on
+		// the same shadow map view is always available -- no capability gap here.
+		return true;
 	}
 	return false;
 }
@@ -185,6 +163,38 @@ bool vulkan_get_property(gr_property prop, void* dest)
 	}
 }
 
+void vulkan_get_debug_stats(gr_debug_stats& stats)
+{
+	const auto& frameStats = getDrawManager()->getFrameStats();
+
+	stats.draw_stats_valid = true;
+	stats.draw_calls = frameStats.drawCalls;
+	stats.draw_indexed_calls = frameStats.drawIndexedCalls;
+	stats.total_vertices = frameStats.totalVertices;
+	stats.total_indices = frameStats.totalIndices;
+	stats.apply_material_calls = frameStats.applyMaterialCalls;
+	stats.apply_material_failures = frameStats.applyMaterialFailures;
+	stats.no_pipeline_skips = frameStats.noPipelineSkips;
+	stats.on_demand_texture_uploads = frameStats.onDemandTextureUploads;
+
+	stats.descriptor_sets_allocated = static_cast<int>(getDescriptorManager()->getSetsAllocatedThisFrame());
+	stats.descriptor_writes = static_cast<int>(getDescriptorManager()->getWritesThisFrame());
+	stats.pipeline_count = getPipelineManager()->getPipelineCount();
+}
+
+void vulkan_get_memory_stats(gr_memory_stats& stats)
+{
+	auto* memoryManager = getMemoryManager();
+	if (memoryManager == nullptr) {
+		return;
+	}
+
+	stats.gpu_purpose_valid = true;
+	stats.gpu_texture_bytes = memoryManager->getTextureBytes();
+	stats.gpu_geometry_bytes = memoryManager->getGeometryBytes();
+	stats.gpu_render_target_bytes = memoryManager->getRenderTargetBytes();
+}
+
 void vulkan_push_debug_group(const char* name)
 {
 	auto* renderer = getRendererInstance();
@@ -222,12 +232,16 @@ void vulkan_imgui_render_draw_data()
 	if (renderer) {
 		ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), renderer->getVkCurrentCommandBuffer());
 
-		// ImGui recorded its own pipeline/descriptor/viewport/scissor binds
-		// directly on the command buffer, mid-pass. Anything the engine draws
-		// before the next pass boundary (e.g. gr_flip's debug overlay or cached
-		// UI model instances) would otherwise run with ImGui's pipeline still
-		// bound because the tracker believes its own pipeline is current.
+		// ImGui just bound its own pipeline/descriptor set directly on the command buffer,
+		// inside the same (already-active) render pass FSO's own draws share -- it can't begin
+		// its own pass here, unlike the other raw recorders whose staleness setRenderPass()
+		// alone recovers from. Without this, the next tracked draw (e.g. a HUD gauge rendered
+		// after the profiler overlay) can skip rebinding its own pipeline/descriptor set because
+		// the tracker's/draw-manager's cached handles still match what THEY last bound, even
+		// though ImGui has since changed what's actually bound on the command buffer -- see
+		// VulkanStateTracker::invalidateExternalBindings().
 		getStateTracker()->invalidateExternalBindings();
+		getDrawManager()->invalidateDrawStateCaches();
 	}
 }
 
@@ -532,6 +546,8 @@ void init_function_pointers()
 
 	gr_screen.gf_is_capable = vulkan_is_capable;
 	gr_screen.gf_get_property = vulkan_get_property;
+	gr_screen.gf_get_debug_stats = vulkan_get_debug_stats;
+	gr_screen.gf_get_memory_stats = vulkan_get_memory_stats;
 
 	gr_screen.gf_push_debug_group = vulkan_push_debug_group;
 	gr_screen.gf_pop_debug_group = vulkan_pop_debug_group;
@@ -563,6 +579,35 @@ void init_function_pointers()
 
 } // anonymous namespace
 
+// Outside the anonymous namespace: declared in gr_vulkan.h so the RTAO fallback
+// trigger in vulkan_deferred_lighting_finish() (VulkanDeferred.cpp) can call it
+// when shadow rendering didn't build this frame's TLAS.
+void vulkan_build_shadow_tlas()
+{
+	if (auto* rt = getRaytracingManager()) {
+		// vkCmdBuildAccelerationStructuresKHR (and the memory barrier that follows
+		// it in buildTlas()) must be recorded outside any render pass instance.
+		// This is called once per frame, before the shadow map render pass begins,
+		// while the previous render pass (G-buffer/scene) is typically still
+		// active -- end it here. vulkan_shadow_map_start()'s first_pass branch
+		// skips its own endRenderPass() call when it finds none active.
+		auto* stateTracker = getStateTracker();
+		if (stateTracker->getCurrentRenderPass()) {
+			stateTracker->getCommandBuffer().endRenderPass();
+			stateTracker->setRenderPass(vk::RenderPass());
+		}
+
+		rt->buildTlas();
+		// Refresh the Global set's live TLAS fallback so every writeSet(Global)
+		// this frame picks up the freshly built TLAS automatically -- see
+		// DescriptorFallbacks::shadowTlas.
+		getDescriptorManager()->setCurrentShadowTlas(rt->getTlasForShaderBinding());
+		// The memoized per-frame Global set (VulkanDrawManager) must rebuild so the
+		// new TLAS reaches subsequent draws' Set 0 instead of a cached stale one.
+		getDrawManager()->invalidateGlobalSet();
+	}
+}
+
 void initialize_function_pointers() {
 	init_function_pointers();
 }

code/graphics/vulkan/gr_vulkan.h

@@ -11,6 +11,13 @@ bool initialize(std::unique_ptr<os::GraphicsOperations>&& graphicsOps);
 
 VulkanRenderer* getRendererInstance();
 
+// Build (or refresh) this frame's raytraced-shadow/RTAO TLAS. Safe to call more
+// than once per frame (VulkanRaytracingManager::buildTlas() is frame-guarded),
+// but acceleration-structure builds must be recorded outside a render pass, so
+// this ends the state tracker's current render pass (and clears it in the
+// tracker) if one is active.
+void vulkan_build_shadow_tlas();
+
 void cleanup();
 
 } // namespace graphics::vulkan

code/lab/dialogs/lab_ui.cpp

@@ -528,6 +528,32 @@ void LabUi::build_shadow_method_combobox()
 	}
 }
 
+static const char* rt_shadow_quality_settings[] = {
+	"Low (directional lights only)",
+	"High (also point/tube/cone lights)",
+};
+
+void LabUi::build_rt_shadow_quality_combobox()
+{
+	// Only meaningful when raytraced shadows are actually the active method.
+	if (!shadows_raytracing_supported() || Shadow_render_method != ShadowRenderMethod::Raytraced) {
+		return;
+	}
+
+	with_Combo("RT Shadow Quality", rt_shadow_quality_settings[static_cast<int>(Rt_shadow_quality)])
+	{
+		for (int n = 0; n < IM_ARRAYSIZE(rt_shadow_quality_settings); n++) {
+			bool is_selected = static_cast<int>(Rt_shadow_quality) == n;
+
+			if (Selectable(rt_shadow_quality_settings[n], is_selected))
+				LabRenderer::setRtShadowQuality(static_cast<RTShadowQuality>(n));
+
+			if (is_selected)
+				SetItemDefaultFocus();
+		}
+	}
+}
+
 void LabUi::build_max_rt_shadow_lights_slider()
 {
 	// Only meaningful when raytraced shadows are actually the active method.
@@ -539,6 +565,19 @@ void LabUi::build_max_rt_shadow_lights_slider()
 	if (SliderInt("Max Raytraced Shadow Lights", &count, 1, 8)) {
 		LabRenderer::setMaxRtShadowLights(count);
 	}
+
+	// The local-light cap is only consulted at High quality, so don't offer it at Low --
+	// same as how the sun size slider only appears once its override is on.
+	if (Rt_shadow_quality != RTShadowQuality::High) {
+		return;
+	}
+
+	// 0 is a useful setting rather than a degenerate one: it turns local-light shadows off
+	// without leaving High, which isolates what the directional lights are contributing.
+	int local_count = Max_rt_shadow_local_lights;
+	if (SliderInt("Max Raytraced Local Shadow Lights", &local_count, 0, 64)) {
+		LabRenderer::setMaxRtShadowLocalLights(local_count);
+	}
 }
 
 void LabUi::build_rt_shadow_bias_sliders()
@@ -559,6 +598,84 @@ void LabUi::build_rt_shadow_bias_sliders()
 	}
 }
 
+void LabUi::build_shadow_penumbra_sliders()
+{
+	// The sample count is a raytracing cost knob, so it only appears when raytraced shadows
+	// are actually the active method. The sun size below is deliberately not gated that way.
+	if (shadows_raytracing_supported() && Shadow_render_method == ShadowRenderMethod::Raytraced) {
+		// Starts at whatever Shadow_quality implies; moving it pins a session-only
+		// override, so the slider stops tracking the quality tier from then on.
+		int samples = shadows_rt_sample_count();
+		if (SliderInt("RT Shadow Samples", &samples, 1, 16)) {
+			LabRenderer::setRtShadowSamples(samples);
+		}
+	}
+
+	// Contact hardening is a shadow-map-only technique (see pcssPenumbraRadius() in
+	// shadows.sdr) -- raytraced shadows size their penumbra from traceShadowRayCone()'s
+	// cone sampling instead, so this has no effect there and isn't worth showing.
+	if (shadow_contact_hardening_supported() && Shadow_render_method == ShadowRenderMethod::ShadowMap) {
+		bool contact_hardening = Shadow_contact_hardening_enabled;
+		if (Checkbox("Shadow Contact Hardening", &contact_hardening)) {
+			LabRenderer::setShadowContactHardening(contact_hardening);
+		}
+	}
+
+	// Overrides whatever size the suns would otherwise use -- their $SunAngularSize, or
+	// the size measured from their bitmaps -- so penumbras can be tried out against any
+	// background; the checkbox's default slider value is Sol's apparent diameter.
+	//
+	// Shown for both shadow methods, because this is the one parameter that drives softness
+	// in both: it sizes the raytraced penumbra cone and scales the shadow map's filter width
+	// (see shadow_smoothness_scale() in shadows.cpp). Sitting on the slider and flipping the
+	// render method is the intended way to check the two against each other.
+	//
+	// It needs a mission background loaded to do anything: it overrides the size of drawn
+	// suns, and with no background the lab lights the scene from common_setup_room_lights()
+	// instead, which draws no suns for this to override.
+	if (Shadow_quality == ShadowQuality::Disabled) {
+		return;
+	}
+
+	bool override_sun = Sun_angular_size_override >= 0.0f;
+	if (Checkbox("Override Sun Angular Size", &override_sun)) {
+		LabRenderer::setSunAngularSizeOverride(override_sun ? SUN_ANGULAR_SIZE_SOL : SUN_ANGULAR_SIZE_UNSPECIFIED);
+	}
+	if (override_sun) {
+		float sun_size = Sun_angular_size_override;
+		if (SliderFloat("Sun Angular Size (deg)", &sun_size, 0.0f, 10.0f)) {
+			LabRenderer::setSunAngularSizeOverride(sun_size);
+		}
+	}
+}
+
+void LabUi::build_rtao_sliders()
+{
+	// Unlike the RT shadow sliders, RTAO is independent of the shadow method --
+	// it only needs ray-query support.
+	if (!rtao_supported()) {
+		return;
+	}
+
+	int samples = Rtao_samples;
+	if (SliderInt("RTAO Samples", &samples, 0, 16)) {
+		LabRenderer::setRtaoSamples(samples);
+	}
+
+	// Radius/strength are the mod-owned lighting-profile values ($RTAO Radius /
+	// $RTAO Strength); these override the active profile for this session only,
+	// same as the exposure/tonemapper controls below.
+	float radius = lighting_profiles::current_rtao_radius();
+	if (SliderFloat("RTAO Radius", &radius, 0.0f, 200.0f)) {
+		lighting_profiles::lab_set_rtao_radius(radius);
+	}
+
+	float strength = lighting_profiles::current_rtao_strength();
+	if (SliderFloat("RTAO Strength", &strength, 0.0f, 2.0f)) {
+		lighting_profiles::lab_set_rtao_strength(strength);
+	}
+}
+
 
 namespace ltp = lighting_profiles;
 using namespace ltp;
@@ -658,10 +775,16 @@ void LabUi::show_render_options()
 
 			build_shadow_method_combobox();
 
+			build_rt_shadow_quality_combobox();
+
 			build_max_rt_shadow_lights_slider();
 
 			build_rt_shadow_bias_sliders();
 
+			build_shadow_penumbra_sliders();
+
+			build_rtao_sliders();
+
 			build_tone_mapper_combobox();
 
 			if (ltp::current_tonemapper() == TonemapperAlgorithm::PPC ||

code/lab/dialogs/lab_ui.h

@@ -44,8 +44,11 @@ class LabUi {
 	void build_texture_quality_combobox();
 	void build_antialiasing_combobox();
 	static void build_shadow_method_combobox();
+	static void build_rt_shadow_quality_combobox();
 	static void build_max_rt_shadow_lights_slider();
 	static void build_rt_shadow_bias_sliders();
+	static void build_shadow_penumbra_sliders();
+	static void build_rtao_sliders();
 	void build_tone_mapper_combobox();
 	void build_model_info_box(ship_info* sip, polymodel* pm) const;
 	void build_subsystem_list(object* objp, ship* shipp) const;

code/lab/labv2.cpp

@@ -2,6 +2,9 @@
 #include "lab/labv2_internal.h"
 #include "lab/manager/lab_manager.h"
 #include "gamesequence/gamesequence.h"
+#include "graphics/rtao.h"
+#include "graphics/shadows.h"
+#include "starfield/starfield.h"
 
 static std::unique_ptr<LabManager> LMGR;
 
@@ -13,11 +16,47 @@ const std::unique_ptr<LabManager> &getLabManager() {
 	return LMGR;
 }
 
+namespace {
+// The lab changes these settings directly, so we save them when the lab opens and restore them when it closes.
+struct LabSavedSettings {
+	RTShadowQuality rt_shadow_quality;
+	float rt_shadow_bias_min;
+	float rt_shadow_bias_max;
+	int rt_shadow_samples_override;
+	float sun_angular_size_override;
+	int rtao_samples;
+	bool shadow_contact_hardening_enabled;
+};
+
+bool Lab_settings_saved = false;
+LabSavedSettings Lab_saved_settings;
+}
+
 void lab_init() {
 	gr_set_clear_color(0, 0, 0);
+
+	Lab_saved_settings = {Rt_shadow_quality,
+		Rt_shadow_bias_min,
+		Rt_shadow_bias_max,
+		Rt_shadow_samples_override,
+		Sun_angular_size_override,
+		Rtao_samples,
+		Shadow_contact_hardening_enabled};
+	Lab_settings_saved = true;
 }
 
 void lab_close(bool reset) {
+	if (Lab_settings_saved) {
+		Rt_shadow_quality = Lab_saved_settings.rt_shadow_quality;
+		Rt_shadow_bias_min = Lab_saved_settings.rt_shadow_bias_min;
+		Rt_shadow_bias_max = Lab_saved_settings.rt_shadow_bias_max;
+		Rt_shadow_samples_override = Lab_saved_settings.rt_shadow_samples_override;
+		Sun_angular_size_override = Lab_saved_settings.sun_angular_size_override;
+		Rtao_samples = Lab_saved_settings.rtao_samples;
+		Shadow_contact_hardening_enabled = Lab_saved_settings.shadow_contact_hardening_enabled;
+		Lab_settings_saved = false;
+	}
+
 	if (reset) {
 		LMGR.reset();
 	}

code/lab/manager/lab_manager.cpp

@@ -412,12 +412,11 @@ void LabManager::onFrame(float frametime) {
 	
 	if (Cmdline_show_imgui_debug)
 		ImGui::ShowDemoWindow();
-	ImGui::Render();
-	gr_imgui_render_draw_data();
 
 	if (CloseThis)
 		close();
 
+	// gr_flip() renders and submits the ImGui frame opened above.
 	gr_flip();
 }
 

code/lab/renderer/lab_renderer.cpp

@@ -256,8 +256,9 @@ void LabRenderer::renderModel(float frametime) {
 
 	gr_reset_clip();
 	gr_set_color_fast(&HUD_color_debug);
-	if (Cmdline_frame_profile) {
-		tracing::frame_profile_process_frame();
+	// The legacy -profile_frame_time text dump. gr_flip() drains the profiler, so this only
+	// renders what the previous frame produced.
+	if (Cmdline_frame_profile && tracing::frame_profiling_active()) {
 		gr_string(gr_screen.center_offset_x + 20, gr_screen.center_offset_y + 100 + gr_get_font_height() + 1,
 			tracing::get_frame_profile_output().c_str(), GR_RESIZE_NONE);
 	}

code/lab/renderer/lab_renderer.h

@@ -3,6 +3,7 @@
 #include "globalincs/pstypes.h"
 #include "globalincs/flagset.h"
 #include "graphics/2d.h"
+#include "graphics/rtao.h"
 #include "graphics/shadows.h"
 #include "lighting/lighting_profiles.h"
 #include "camera/camera.h"
@@ -130,12 +131,27 @@ public:
 		Shadow_render_method = method;
 	}
 
+	// Session-only override, same as setShadowRenderMethod -- does not touch the
+	// persisted Raytraced Shadow Quality option. Safe to change at any time: the
+	// only thing it gates is whether local lights are picked as shadow casters
+	// while filling the light uniforms, which happens fresh every frame, so
+	// nothing has to be rebuilt for the switch to take effect.
+	static void setRtShadowQuality(RTShadowQuality quality) {
+		Rt_shadow_quality = quality;
+	}
+
 	// Session-only override, same as setShadowRenderMethod -- does not touch the
 	// persisted Max Raytraced Shadow Lights option.
 	static void setMaxRtShadowLights(int count) {
 		Max_rt_shadow_lights = count;
 	}
 
+	// Session-only override, same as setMaxRtShadowLights -- does not touch the persisted
+	// Max Raytraced Local Shadow Lights option. Only consulted at RTShadowQuality::High.
+	static void setMaxRtShadowLocalLights(int count) {
+		Max_rt_shadow_local_lights = count;
+	}
+
 	// Session-only overrides, same as setMaxRtShadowLights -- do not touch the
 	// persisted Min/Max Raytraced Shadow Bias options. See Rt_shadow_bias_min/max
 	// in shadows.h.
@@ -147,6 +163,33 @@ public:
 		Rt_shadow_bias_max = bias;
 	}
 
+	// Ray count normally follows Shadow_quality (see shadows_rt_sample_count()), which is
+	// fixed at startup because the shadow map is sized then. The ray count isn't, so the
+	// lab can sweep it live through this session-only override. See
+	// Rt_shadow_samples_override in shadows.h.
+	static void setRtShadowSamples(int samples) {
+		Rt_shadow_samples_override = samples;
+	}
+
+	// Session-only override of every sun's $SunAngularSize (degrees of apparent
+	// diameter); pass a negative value to return to the stars.tbl values. See
+	// Sun_angular_size_override in starfield.h.
+	static void setSunAngularSizeOverride(float degrees) {
+		Sun_angular_size_override = degrees;
+	}
+
+	// Session-only override, same as setRtShadowSamples -- does not touch the
+	// persisted Raytraced Ambient Occlusion option. See Rtao_samples in rtao.h.
+	static void setRtaoSamples(int samples) {
+		Rtao_samples = samples;
+	}
+
+	// Session-only override, same as setRtaoSamples -- does not touch the persisted
+	// Shadow Contact Hardening option. See Shadow_contact_hardening_enabled in shadows.h.
+	static void setShadowContactHardening(bool enabled) {
+		Shadow_contact_hardening_enabled = enabled;
+	}
+
 	static void setTonemapper(ltp::TonemapperAlgorithm mode) {
 		ltp::lab_set_tonemapper(mode);
 	}

code/lighting/lighting_profiles.cpp

@@ -97,6 +97,16 @@ float current_exposure()
 	return _current.exposure;
 }
 
+float current_rtao_radius()
+{
+	return _current.rtao_radius;
+}
+
+float current_rtao_strength()
+{
+	return _current.rtao_strength;
+}
+
 piecewise_power_curve_intermediates current_piecewise_intermediates()
 {
 	return calc_intermediates(_current.ppc_values);
@@ -211,6 +221,16 @@ void lab_set_exposure(float exIn)
 	_current.exposure = exIn;
 }
 
+void lab_set_rtao_radius(float radius)
+{
+	_current.rtao_radius = radius;
+}
+
+void lab_set_rtao_strength(float strength)
+{
+	_current.rtao_strength = strength;
+}
+
 void lab_set_tonemapper(TonemapperAlgorithm tnin)
 {
 	_current.tonemapper = tnin;
@@ -381,6 +401,21 @@ void profile::parse(const char* filename, const SCP_string& profile_name, const
 		parsed |= parse_optional_float_into("$PPC Shoulder Angle:", &ppc_values.shoulder_angle);
 		parsed |= parse_optional_float_into("$Exposure:", &exposure);
 
+		if (parse_optional_float_into("$RTAO Radius:", &rtao_radius)) {
+			parsed = true;
+			if (rtao_radius < 0.0f) {
+				error_display(0, "$RTAO Radius: must be >= 0 (got %f); using 0.", rtao_radius);
+				rtao_radius = 0.0f;
+			}
+		}
+		if (parse_optional_float_into("$RTAO Strength:", &rtao_strength)) {
+			parsed = true;
+			if (rtao_strength < 0.0f) {
+				error_display(0, "$RTAO Strength: must be >= 0 (got %f); using 0.", rtao_strength);
+				rtao_strength = 0.0f;
+			}
+		}
+
 		parsed |= adjustment::parse(filename, "$Missile light brightness:", profile_name, &missile_light_brightness);
 		parsed |= adjustment::parse(filename, "$Missile light radius:", profile_name, &missile_light_radius);
 
@@ -444,6 +479,9 @@ void profile::reset()
 
 	exposure = 4.0f;
 
+	rtao_radius = 20.0f;
+	rtao_strength = 1.0f;
+
 	missile_light_brightness.reset();
 	missile_light_radius.reset();
 	missile_light_radius.base = 20.0f;

code/lighting/lighting_profiles.h

@@ -59,6 +59,13 @@ class profile {
 	TonemapperAlgorithm tonemapper;
 	piecewise_power_curve_values ppc_values;
 	float exposure;
+	// Raytraced ambient occlusion tuning (only sampled when rtao_enabled(), see
+	// graphics/rtao.h). Radius is the AO ray length in world units -- it is
+	// content-scale-dependent (fighters vs. capships), which is why it lives in
+	// the mod-owned lighting profile rather than a user option. Strength is an
+	// exponent on the occlusion term (1 = physical, >1 darkens, <1 lightens).
+	float rtao_radius;
+	float rtao_strength;
 	adjustment missile_light_brightness;
 	adjustment missile_light_radius;
 	adjustment laser_light_brightness;
@@ -97,7 +104,11 @@ const piecewise_power_curve_values& current_piecewise_values();
 piecewise_power_curve_intermediates current_piecewise_intermediates();
 piecewise_power_curve_intermediates calc_intermediates(piecewise_power_curve_values input);
 float current_exposure();
+float current_rtao_radius();
+float current_rtao_strength();
 void lab_set_exposure(float exIn);
+void lab_set_rtao_radius(float radius);
+void lab_set_rtao_strength(float strength);
 void lab_set_tonemapper(TonemapperAlgorithm tnin);
 void lab_set_ppc(const piecewise_power_curve_values &ppcin);
 const piecewise_power_curve_values &lab_get_ppc();

code/localization/localize.cpp

@@ -65,7 +65,7 @@ bool *Lcl_unexpected_tstring_check = nullptr;
 // NOTE: with map storage of XSTR strings, the indexes no longer need to be contiguous,
 // but internal strings should still increment XSTR_SIZE to avoid collisions.
 // retail XSTR_SIZE = 1570
-// #define XSTR_SIZE	1940 // This is the next available ID
+// #define XSTR_SIZE	1942 // This is the next available ID
 
 // struct to allow for strings.tbl-determined x offset
 // offset is 0 for english, by default

code/mission/missionparse.cpp

@@ -6278,6 +6278,17 @@ void parse_one_background(background_t *background)
 		sle.div_x = 1;
 		sle.div_y = 1;
 
+		// apparent diameter in degrees, overriding both the sun's stars.tbl entry and the
+		// size that would otherwise be measured from its bitmap. Optional, so missions
+		// written before 27.0 simply don't have it
+		if (optional_string("+AngularSize:")) {
+			stuff_float(&sle.angular_size);
+			if (sle.angular_size < 0.0f) {
+				error_display(0, "+AngularSize: for sun '%s' must be >= 0 (got %f); ignoring it.", sle.filename, sle.angular_size);
+				sle.angular_size = SUN_ANGULAR_SIZE_UNSPECIFIED;
+			}
+		}
+
 		// add it
 		background->suns.push_back(sle);
 	}
@@ -9791,3 +9802,19 @@ bool check_for_25_1_data()
 
 	return false;
 }
+
+bool check_for_27_0_data()
+{
+	// a sun that carries its own apparent diameter (+AngularSize:) can't be represented
+	// in an older mission file
+	for (const auto &background : Backgrounds)
+	{
+		for (const auto &sun : background.suns)
+		{
+			if (sun.angular_size >= 0.0f)
+				return true;
+		}
+	}
+
+	return false;
+}

code/mission/missionparse.h

@@ -61,6 +61,7 @@ extern bool check_for_23_3_data();
 extern bool check_for_24_1_data();
 extern bool check_for_24_3_data();
 extern bool check_for_25_1_data();
+extern bool check_for_27_0_data();
 
 #define WING_PLAYER_BASE	0x80000  // used by Fred to tell ship_index in a wing points to a player
 

code/missioneditor/missionsave.cpp

@@ -1035,6 +1035,15 @@ int Fred_mission_save::save_bitmaps()
 			required_string_fred("+Scale:");
 			parse_comments();
 			fout(" %f", sle->scale_x);
+
+			// apparent diameter, only written when this mission actually sets one; see
+			// check_for_27_0_data()
+			FRED_ENSURE_PROPERTY_VERSION_WITH_DEFAULT_F("+AngularSize:",
+				1,
+				";;FSO 27.0.0;;",
+				SUN_ANGULAR_SIZE_UNSPECIFIED,
+				" %f",
+				sle->angular_size);
 		}
 
 		// save background bitmaps by filename
@@ -3171,7 +3180,15 @@ void Fred_mission_save::save_mission_internal(const char* pathname)
 	auto version_24_1 = gameversion::version(24, 1);
 	auto version_24_3 = gameversion::version(24, 3);
 	auto version_25_1 = gameversion::version(25, 1);
-	if (MISSION_VERSION >= version_25_1) {
+	auto version_27_0 = gameversion::version(27, 0);
+	if (MISSION_VERSION >= version_27_0) {
+		Warning(LOCATION,
+			"Notify an SCP coder: now that the required mission version is at least 27.0, the check_for_27_0_data(), "
+			"check_for_25_1_data(), check_for_24_3_data(), check_for_24_1_data(), and check_for_23_3_data() code can "
+			"be removed");
+	} else if (check_for_27_0_data()) {
+		The_mission.required_fso_version = version_27_0;
+	} else if (MISSION_VERSION >= version_25_1) {
 		Warning(LOCATION,
 			"Notify an SCP coder: now that the required mission version is at least 25.1, the check_for_25_1_data(), "
 			"check_for_24_3_data(), check_for_24_1_data(), and check_for_23_3_data() code can be removed");

code/missionui/missionpause.cpp

@@ -26,7 +26,7 @@
 #include "popup/popup.h"
 #include "sound/audiostr.h"
 #include "ui/ui.h"
-#include "weapon/weapon.h"	
+#include "weapon/weapon.h"
 
 
 

code/missionui/missionscreencommon.cpp

@@ -33,6 +33,8 @@
 #include "io/timer.h"
 #include "lighting/lighting.h"
 #include "lighting/lighting_profiles.h"
+#include "starfield/starfield.h"
+#include "starfield/sun_disc.h"
 #include "missionui/chatbox.h"
 #include "missionui/missionbrief.h"
 #include "missionui/missionscreencommon.h"
@@ -1989,16 +1991,23 @@ void draw_model_rotating(model_render_params *render_info, int ship_class, int m
  */
 void common_setup_room_lights()
 {
+	// These stand in for a sun rather than for a point source, so they get a sun's apparent
+	// size: for a directional light source_radius is the tangent of the angular radius, and
+	// it is what sizes both the raytraced penumbra cone and the shadow map's filter width
+	// (see shadow_smoothness_scale() in shadows.cpp). Leaving it at 0 would read as a light
+	// with no extent at all and give these rooms hard, aliased shadow edges.
+	const float room_light_source_radius = sun_disc_tangent_from_diameter(SUN_ANGULAR_SIZE_SOL);
+
 	light_reset();
 	auto tempv = vm_vec_new(-1.0f,0.3f,-1.0f);
 	auto tempc = hdr_color(1.0f,0.95f,0.9f, 0.0f, 1.5f);
-	light_add_directional(&tempv,-1,false,&tempc);
+	light_add_directional(&tempv,-1,false,&tempc,room_light_source_radius);
 	tempv.xyz={-0.4f,0.4f,1.1f};
 	tempc = hdr_color(0.788f,0.886f,1.0f,0.0f,1.5f);
-	light_add_directional(&tempv,-1,false,&tempc);
+	light_add_directional(&tempv,-1,false,&tempc,room_light_source_radius);
 	tempv.xyz={0.4f,0.1f,0.4f};
 	tempc = hdr_color(1.0f,1.0f,1.0f,0.0f,0.4f);
-	light_add_directional(&tempv,-1,false,&tempc);
+	light_add_directional(&tempv,-1,false,&tempc,room_light_source_radius);
 	gr_set_ambient_light(53, 53, 53);
 }
 

code/mod_table/mod_table.cpp

@@ -853,6 +853,12 @@ void parse_mod_table(const char *filename)
 				}
 			}
 
+			// Per-cascade shadow map filter radius, in shadow map UV units, for a
+			// Sol-sized sun. It is no longer the final width: shadow_cascade_params_bind()
+			// scales these by the sun's apparent size relative to Sol, so that the same
+			// $SunAngularSize: drives both shadow-mapped and raytraced softness. A mod that
+			// tuned these against retail/MediaVPs sun art keeps the look it tuned for --
+			// see shadow_smoothness_scale() in shadows.cpp for why Sol is the reference.
 			if (optional_string("$Shadow Smoothness Factor:")) {
 				SCP_vector<float> smoothness;
 				stuff_float_list(smoothness);

code/model/model.h

@@ -1056,6 +1056,19 @@ void model_load_texture(polymodel *pm, int i, const char *file);
 // Returns a pointer to the polymodel structure for model 'n'
 polymodel *model_get(int model_num);
 
+/**
+ * @brief Memory usage summary across all currently loaded polygon models, for the profiler
+ * overlay's memory panel
+ */
+struct model_memory_stats {
+	bool valid = false;
+	int model_count = 0;
+	size_t vertex_bytes = 0;   // sum of vert_source.Vertex_list_size across loaded models
+	size_t index_bytes = 0;    // sum of vert_source.Index_list_size across loaded models
+	size_t bsp_data_bytes = 0; // sum of submodel[].bsp_data_size (collision/interp tree data)
+};
+model_memory_stats model_get_memory_stats();
+
 int num_model_instances();
 polymodel_instance* model_get_instance(int model_instance_num);
 

code/model/modelread.cpp

@@ -411,6 +411,28 @@ void model_page_in_stop()
 	}
 }
 
+model_memory_stats model_get_memory_stats()
+{
+	model_memory_stats stats;
+	stats.valid = true;
+
+	for (const auto pm : Polygon_models) {
+			if (pm == nullptr) {
+			continue;
+		}
+
+		stats.model_count++;
+		stats.vertex_bytes += pm->vert_source.Vertex_list_size;
+		stats.index_bytes += pm->vert_source.Index_list_size;
+
+		for (int j = 0; j < pm->n_models; j++) {
+			stats.bsp_data_bytes += pm->submodel[j].bsp_data_size;
+		}
+	}
+
+	return stats;
+}
+
 void model_init()
 {
 	int i;

code/object/object.cpp

@@ -535,6 +535,19 @@ int obj_allocate(bool essential)
 	return objnum;
 }
 
+object_memory_stats obj_get_memory_stats()
+{
+	object_memory_stats stats;
+
+	stats.objects_used = Num_objects;
+	stats.objects_peak = num_objects_hwm;
+
+	stats.ships_used = ship_get_num_ships();
+	stats.weapons_used = Num_weapons;
+
+	return stats;
+}
+
 /**
  * Frees up an object  
  *

code/object/object.h

@@ -432,5 +432,23 @@ void physics_apply_pstate_to_object(object* objp, const physics_snapshot& source
  */
 int obj_raw_pof_create(const char* pof_filename, const matrix* orient, const vec3d* pos);
 
+/**
+ * @brief Occupancy snapshot of the object/ship/weapon pools, for the profiler overlay's memory panel
+ *
+ * @details These pools are fixed-size static arrays, so their footprint is a compile-time
+ * constant; what's actually useful to report is how full they are.
+ */
+struct object_memory_stats {
+	int objects_used = 0;
+	int objects_max = MAX_OBJECTS;
+	int objects_peak = 0;
+
+	int ships_used = 0;
+	int ships_max = MAX_SHIPS;
+
+	int weapons_used = 0;
+	int weapons_max = MAX_WEAPONS;
+};
+object_memory_stats obj_get_memory_stats();
 
 #endif

code/options/manager/ingame_options_manager.cpp

@@ -176,12 +176,11 @@ void OptConfigurator::onFrame() {
 	
 	if (Cmdline_show_imgui_debug)
 		ImGui::ShowDemoWindow();
-	ImGui::Render();
-	gr_imgui_render_draw_data();
 
 	if (CloseThis) {
 		close();
 	}
 
+	// gr_flip() renders and submits the ImGui frame opened above.
 	gr_flip();
 }

code/osapi/osapi.cpp

@@ -15,6 +15,7 @@
 #include "graphics/2d.h"
 #include "graphics/openxr.h"
 #include "io/joy_ff.h"
+#include "tracing/tracing.h"
 
 #include <fcntl.h>
 #include <utf8.h>
@@ -38,6 +39,12 @@
 #include "utils/finally.h"
 #endif
 
+#if defined(__APPLE__)
+#include <mach/mach.h>
+#elif defined(__linux__)
+#include <unistd.h>
+#endif
+
 namespace
 {
 	const char* ORGANIZATION_NAME = "HardLightProductions";
@@ -254,6 +261,7 @@ namespace
 // Windows specific includes
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
+#include <psapi.h>
 #include <backends/imgui_impl_sdl3.h>
 
 // go through all windows and try and find the one that matches the search string
@@ -833,18 +841,23 @@ static void handle_sdl_event(const SDL_Event& event) {
 	using namespace os::events;
 
 	bool imgui_processed_this = false;
-	if ((gameseq_get_state() == GS_STATE_LAB) || (gameseq_get_state() == GS_STATE_INGAME_OPTIONS)) {
+	// The profiler overlay is drawn from gr_flip(), so it can be on screen in any state — it
+	// needs input forwarded wherever it is active, not in a fixed list of states.
+	const bool imgui_state = (gameseq_get_state() == GS_STATE_LAB) || (gameseq_get_state() == GS_STATE_INGAME_OPTIONS);
+	if (imgui_state || tracing::frame_profiling_active()) {
 		//In these states, we always need to forward inputs to ImGUI, and depending on the ImGUI state and the input type, we must consume it here instead of passing it to FSO.
 		const SDL_Event imgui_event = scale_imgui_mouse_event(event);
 		ImGui_ImplSDL3_ProcessEvent(&imgui_event);
 
+		// In other states, the game also needs mouse motion while the pointer is over the overlay.
+		// If the overlay consumed the motion, mouse flight would stop there.
 		imgui_processed_this = (ImGui::GetIO().WantCaptureKeyboard &&
 									(event.type == SDL_EventType::SDL_EVENT_KEY_UP ||
 									 event.type == SDL_EventType::SDL_EVENT_KEY_DOWN)) ||
 							   (ImGui::GetIO().WantCaptureMouse &&
 									(event.type == SDL_EventType::SDL_EVENT_MOUSE_BUTTON_UP ||
 				 					 event.type == SDL_EventType::SDL_EVENT_MOUSE_BUTTON_DOWN||
-									 event.type == SDL_EventType::SDL_EVENT_MOUSE_MOTION));
+									 (imgui_state && event.type == SDL_EventType::SDL_EVENT_MOUSE_MOTION)));
 	}
 
 	if (!imgui_processed_this) {
@@ -1105,3 +1118,36 @@ void os_android_touch_overlay_init()
 }
 #endif
 
+os_memory_stats os_get_memory_stats()
+{
+	os_memory_stats stats;
+
+#if defined(WIN32)
+	PROCESS_MEMORY_COUNTERS counters;
+	if (GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) {
+		stats.valid = true;
+		stats.resident_bytes = counters.WorkingSetSize;
+	}
+#elif defined(__APPLE__)
+	mach_task_basic_info_data_t info;
+	mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
+	if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO, reinterpret_cast<task_info_t>(&info), &count) ==
+		KERN_SUCCESS) {
+		stats.valid = true;
+		stats.resident_bytes = info.resident_size;
+	}
+#elif defined(__linux__)
+	// Field 2 of /proc/self/statm is the resident set size, in pages -- see proc(5).
+	if (FILE* statm = fopen("/proc/self/statm", "r")) {
+		long resident_pages = 0;
+		if (fscanf(statm, "%*d %ld", &resident_pages) == 1) {
+			stats.valid = true;
+			stats.resident_bytes = static_cast<size_t>(resident_pages) * static_cast<size_t>(sysconf(_SC_PAGESIZE));
+		}
+		fclose(statm);
+	}
+#endif
+
+	return stats;
+}
+

code/osapi/osapi.h

@@ -107,6 +107,20 @@ void os_android_touch_overlay_toggle(bool status);
 void os_android_set_flags_string(const char* json);
 #endif
 
+/**
+ * @brief Process-wide memory usage snapshot, for the profiler overlay's memory panel
+ *
+ * @details Reports the resident set size (RSS) of the FSO process: the physical RAM the operating
+ * system currently has mapped for this process, across every subsystem (engine heap, Lua heap,
+ * OpenAL buffers, driver-side graphics allocations). Not available on every platform, hence the
+ * "valid" flag -- see os_get_memory_stats().
+ */
+struct os_memory_stats {
+	bool valid = false;
+	size_t resident_bytes = 0;
+};
+os_memory_stats os_get_memory_stats();
+
 namespace os
 {
 	/**

code/scripting/scripting.cpp

@@ -1067,6 +1067,21 @@ void scripting_state_close()
 	scripting_state_inited = 0;
 }
 
+scripting_memory_stats scripting_get_memory_stats()
+{
+	scripting_memory_stats stats;
+
+	lua_State* L = Script_system.GetLuaSession();
+	if (L == nullptr) {
+		return stats;
+	}
+
+	stats.valid = true;
+	stats.lua_heap_bytes = static_cast<size_t>(lua_gc(L, LUA_GCCOUNT, 0)) * 1024 +
+		static_cast<size_t>(lua_gc(L, LUA_GCCOUNTB, 0));
+	return stats;
+}
+
 void scripting_state_do_frame(float  /*frametime*/, bool doKeys)
 {
 	// just incase something is wrong

code/scripting/scripting.h

@@ -88,6 +88,18 @@ void scripting_state_init();
 void scripting_state_close();
 void scripting_state_do_frame(float frametime, bool doKeys);
 
+/**
+ * @brief Lua heap usage snapshot, for the profiler overlay's memory panel
+ *
+ * @details Reports Lua's own GC byte count for the main script state (see lua_gc(),
+ * LUA_GCCOUNT/LUA_GCCOUNTB). Invalid before the Lua state is created or after it is torn down.
+ */
+struct scripting_memory_stats {
+	bool valid = false;
+	size_t lua_heap_bytes = 0;
+};
+scripting_memory_stats scripting_get_memory_stats();
+
 const scripting::HookBase* scripting_string_to_action(const char* action);
 ConditionalType scripting_string_to_condition(const char* condition);
 

code/ship/ship.cpp

@@ -922,12 +922,16 @@ ship_obj *get_ship_obj_ptr_from_index(int index)
  */
 int ship_get_num_ships()
 {
-	int count;
-	ship_obj *so;
+	int count = 0;
 
-	count = 0;
-	for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) )
-	{
+	// Ship_obj_list is only list_init()'d by ship_obj_list_init(), which runs on entering gameplay;
+	// this can be called before that (e.g. by the profiler overlay's memory stats from the main
+	// menu), in which case GET_FIRST() returns the list head's zero-initialized null next pointer.
+	if (GET_FIRST(&Ship_obj_list) == nullptr) {
+		return count;
+	}
+
+	for (auto so : list_range(&Ship_obj_list)) {
 		if (Objects[so->objnum].flags[Object::Object_Flags::Should_be_dead])
 			continue;
 

code/sound/sound.cpp

@@ -48,7 +48,7 @@ struct loaded_sound {
 SCP_vector<loaded_sound> Sounds;
 
 int Sound_enabled = FALSE;				// global flag to turn sound on/off
-size_t Snd_sram;								// mem (in bytes) used up by storing sounds in system memory
+size_t Snd_sram;								// bytes held in OpenAL sound-effect and music-streaming buffers
 
 float Default_sound_volume = 1.0f;		// range is 0 -> 1, used for non-music sound fx
 float Master_sound_volume = Default_sound_volume;
@@ -1392,6 +1392,13 @@ int snd_num_playing()
 	return ds_get_number_channels();
 }
 
+sound_memory_stats snd_get_memory_stats()
+{
+	sound_memory_stats stats;
+	stats.audio_buffer_bytes = Snd_sram;
+	return stats;
+}
+
 // Return the raw sound data for a loaded sound
 //
 // input:	handle	=>	index into Sounds[] array

code/sound/sound.h

@@ -122,11 +122,23 @@ extern float	Default_sound_volume;		// 0 -> 1.0
 extern float	Default_voice_volume;		// 0 -> 1.0
 extern float	Master_sound_volume;		// 0 -> 1.0
 extern float	Master_voice_volume;		// 0 -> 1.0
-extern size_t		Snd_sram;					// System memory consumed by sound data
+extern size_t		Snd_sram;					// Bytes held in OpenAL sound-effect and music-streaming buffers
 extern float aav_voice_volume;
 extern float aav_music_volume;
 extern float aav_effect_volume;
 
+/**
+ * @brief Audio buffer usage snapshot, for the profiler overlay's memory panel
+ *
+ * @details Reports Snd_sram: the bytes held in OpenAL buffers for loaded sound effects and the
+ * music-streaming ring buffers. This is buffer data handed to the OpenAL driver, not an FSO heap
+ * allocation, so it is a lower bound on the audio subsystem's real footprint.
+ */
+struct sound_memory_stats {
+	size_t audio_buffer_bytes = 0;
+};
+sound_memory_stats snd_get_memory_stats();
+
 void snd_set_effects_volume(float volume);
 
 void snd_set_voice_volume(float volume);

code/source_groups.cmake

@@ -481,6 +481,8 @@ add_file_folder("Graphics"
 	graphics/shader_types.cpp
 	graphics/shader_types.h
 	graphics/render_queue.h
+	graphics/rtao.cpp
+	graphics/rtao.h
 	graphics/shadows.cpp
 	graphics/shadows.h
 	graphics/tmapper.h
@@ -1760,6 +1762,8 @@ add_file_folder("Starfield"
 	starfield/nebula.h
 	starfield/starfield.cpp
 	starfield/starfield.h
+	starfield/sun_disc.cpp
+	starfield/sun_disc.h
 	starfield/supernova.cpp
 	starfield/supernova.h
 	starfield/starfield_flags.h
@@ -1791,6 +1795,8 @@ add_file_folder("Tracing"
 	tracing/MainFrameTimer.cpp
 	tracing/Monitor.h
 	tracing/Monitor.cpp
+	tracing/ProfilerOverlay.h
+	tracing/ProfilerOverlay.cpp
 	tracing/scopes.cpp
 	tracing/scopes.h
 	tracing/ThreadedEventProcessor.h

code/starfield/starfield.cpp

@@ -34,6 +34,8 @@
 #include "render/batching.h"
 #include "starfield/nebula.h"
 #include "starfield/starfield.h"
+#include "graphics/shadows.h"
+#include "starfield/sun_disc.h"
 #include "starfield/supernova.h"
 #include "tracing/tracing.h"
 #include "utils/Random.h"
@@ -92,6 +94,11 @@ typedef struct starfield_bitmap {
 	int glow_fps;
 	int xparent;
 	float r, g, b, i;		// only for suns
+	float angular_size;								// only for suns -- this sun's apparent diameter from stars.tbl;
+													// see SUN_ANGULAR_SIZE_UNSPECIFIED
+	float disc_fraction;							// only for suns -- cached sun_disc_measure_bitmap() result for
+													// disc_measured_for; negative means "not measured yet"
+	int disc_measured_for;							// only for suns -- bitmap_id disc_fraction was measured from
 	int glare;										// only for suns
 	int flare;										// Is there a lens-flare for this sun?
 	flare_info flare_infos[MAX_FLARE_COUNT];		// each flare can use a texture in flare_bmp, with different scale
@@ -107,11 +114,14 @@ typedef struct starfield_bitmap_instance {
 	float scale_x, scale_y;							// x and y scale
 	int div_x, div_y;								// # of x and y divisions
 	angles ang;										// angles from FRED
+	float angular_size;								// only for suns -- this mission's apparent diameter for the sun,
+													// in degrees; see SUN_ANGULAR_SIZE_UNSPECIFIED
 	int star_bitmap_index;							// index into starfield_bitmap array
 	int n_verts;
 	vertex *verts;
 
-	starfield_bitmap_instance() : scale_x(1.0f), scale_y(1.0f), div_x(1), div_y(1), star_bitmap_index(0), n_verts(0), verts(NULL) {
+	starfield_bitmap_instance() : scale_x(1.0f), scale_y(1.0f), div_x(1), div_y(1),
+		angular_size(SUN_ANGULAR_SIZE_UNSPECIFIED), star_bitmap_index(0), n_verts(0), verts(nullptr) {
 		ang.p = 0.0f;
 		ang.b = 0.0f;
 		ang.h = 0.0f;
@@ -124,6 +134,8 @@ static SCP_vector<starfield_bitmap_instance> Starfield_bitmap_instances;
 
 // sun bitmaps and sun glow bitmaps
 static SCP_vector<starfield_bitmap> Sun_bitmaps;
+
+float Sun_angular_size_override = -1.0f;
 static SCP_vector<starfield_bitmap_instance> Suns;
 
 // Goober5000
@@ -400,6 +412,9 @@ static void starfield_bitmap_entry_init(starfield_bitmap *sbm)
 	sbm->bitmap_id = -1;
 	sbm->glow_bitmap = -1;
 	sbm->glow_n_frames = 1;
+	sbm->angular_size = SUN_ANGULAR_SIZE_UNSPECIFIED;
+	sbm->disc_fraction = -1.0f;
+	sbm->disc_measured_for = -1;
 
 	for (i = 0; i < MAX_FLARE_BMP; i++) {
 		sbm->flare_bitmaps[i].bitmap_id = -1;
@@ -497,6 +512,20 @@ void parse_startbl(const char *filename)
 						Warning(LOCATION, "%s", warning.c_str());		// customized case is significant
 				}
 
+				// apparent diameter of the sun's disc in degrees (Sol is ~0.53). Only affects
+				// raytraced shadows, which get a penumbra sized to match. Left out, the size is
+				// measured from the sun bitmap instead -- see sun_angular_radius_tangent() -- so
+				// use 0 to ask for hard shadows and "derived" to say "measure it" outright.
+				if (optional_string("$SunAngularSize:")) {
+					if ( !optional_string("derived") ) {
+						stuff_float(&sbm.angular_size);
+						if (sbm.angular_size < 0.0f) {
+							error_display(0, "$SunAngularSize: for sun '%s' must be >= 0 (got %f); measuring the bitmap instead.", sbm.filename, sbm.angular_size);
+							sbm.angular_size = SUN_ANGULAR_SIZE_UNSPECIFIED;
+						}
+					}
+				}
+
 				// lens flare stuff
 				if (optional_string("$Flare:")) {
 					sbm.flare = 1;
@@ -855,6 +884,14 @@ void stars_pre_level_init(bool clear_backgrounds)
 				sb.bitmap_id = -1;
 			}
 
+			// drop any derived angular size along with the bitmap it was measured from. The
+			// handle check in sun_angular_radius_tangent() can't be relied on for this: bm_load()
+			// hands back a recycled slot index, so a reloaded bitmap can come back on the handle
+			// it had before. This is what makes a size change take effect when the background
+			// changes -- which, outside of a mission, is every time the lab switches backgrounds.
+			sb.disc_fraction = -1.0f;
+			sb.disc_measured_for = -1;
+
 			if (sb.glow_bitmap > 0) {
 				bm_release(sb.glow_bitmap);
 				sb.glow_bitmap = -1;
@@ -1270,6 +1307,89 @@ void stars_get_sun_pos(int sun_n, vec3d *pos)
 	vm_vec_unrotate(pos, &temp, &rot);
 }
 
+/**
+ * @brief The apparent diameter this sun should use, in degrees, or negative if nothing sets one
+ *
+ * @param mission_angular_size this sun instance's +AngularSize: from the mission file
+ */
+static float sun_explicit_angular_size(const starfield_bitmap *bm, float mission_angular_size)
+{
+	// the first layer that specifies a size wins: the LabUi session override, then the
+	// mission's value for this sun instance, then the sun's stars.tbl entry
+	for (float degrees : {Sun_angular_size_override, mission_angular_size, bm->angular_size}) {
+		if (degrees >= 0.0f) {
+			return degrees;
+		}
+	}
+
+	return SUN_ANGULAR_SIZE_UNSPECIFIED;
+}
+
+/**
+ * @brief How much of this sun's bitmap is its emitting disc, measuring it on first use
+ *
+ * @return the disc fraction, or 0 for a sun whose bitmap has no measurable disc
+ */
+static float sun_measured_disc_fraction(starfield_bitmap *bm)
+{
+	// measuring reads the bitmap's pixels, so it happens once and is cached against the
+	// handle it was measured from
+	if ( (bm->disc_fraction >= 0.0f) && (bm->disc_measured_for == bm->bitmap_id) ) {
+		return bm->disc_fraction;
+	}
+
+	const float measured = sun_disc_measure_bitmap(bm->bitmap_id);
+
+	// both a bitmap we couldn't read and one with no drawn disc at all fall back to hard
+	// shadows, but they are very different things -- keep them apart in the log, or a broken
+	// read reads as "working as intended". Neither is worth a Warning(): this runs for every
+	// sun in every mission, not just for content that asked for it, and hard shadows are a
+	// perfectly serviceable outcome
+	if (measured < 0.0f) {
+		mprintf(("Sun '%s': could not read the bitmap to measure it, using hard shadows\n", bm->filename));
+	} else if (measured == 0.0f) {
+		// mods ship blank sun bitmaps to get a light source without a visible sun
+		mprintf(("Sun '%s': no drawn disc, using hard shadows\n", bm->filename));
+	} else {
+		// logged once per sun bitmap, not per frame -- this is what a mod tunes its suns
+		// against. The size is quoted at +Scale: 1.0 since the measurement is a property of
+		// the bitmap; a mission scaling its sun scales this with it.
+		mprintf(("Sun '%s': measured disc fraction %.3f (%.2f degrees at +Scale: 1.0)\n", bm->filename, measured,
+			fl_degrees(2.0f * atanf(sun_disc_tangent_from_fraction(measured, 1.0f)))));
+	}
+
+	bm->disc_fraction = (measured > 0.0f) ? measured : 0.0f;
+	bm->disc_measured_for = bm->bitmap_id;
+
+	return bm->disc_fraction;
+}
+
+/**
+ * @brief Tangent of a sun's angular radius, which is what a directional light's source_radius is
+ *
+ * See traceShadowRayCone() in shadows.sdr: for directional lights the source radius *is* the
+ * tangent of the angular radius, so the penumbra widens with occluder distance the way a real
+ * area light's would. 0 means a point source, i.e. hard shadows.
+ *
+ * @param scale_x the mission's +Scale: for this sun instance
+ * @param mission_angular_size this sun instance's +AngularSize: from the mission file
+ */
+static float sun_angular_radius_tangent(starfield_bitmap *bm, float scale_x, float mission_angular_size)
+{
+	const float specified = sun_explicit_angular_size(bm, mission_angular_size);
+
+	if (specified >= 0.0f) {
+		return sun_disc_tangent_from_diameter(specified);
+	}
+
+	// the size is only used to soften shadows, so do not read the bitmap when shadows are off
+	if (Shadow_quality == ShadowQuality::Disabled) {
+		return 0.0f;
+	}
+
+	return sun_disc_tangent_from_fraction(sun_measured_disc_fraction(bm), scale_x);
+}
+
 // draw sun
 void stars_draw_sun(int show_sun)
 {	
@@ -1318,9 +1438,13 @@ void stars_draw_sun(int show_sun)
 		sun_dir = sun_pos;
 		vm_vec_normalize(&sun_dir);
 
-		// add the light source corresponding to the sun, except when rendering to an envmap
-		if ( !Rendering_to_env )
-			light_add_directional(&sun_dir, idx, !bm->glare, bm->i, bm->r, bm->g, bm->b);
+		// add the light source corresponding to the sun, except when rendering to an envmap.
+		// For directional lights, source_radius carries the tangent of the sun's angular
+		// radius (see traceShadowRayCone() in shadows.sdr), sizing its shadow penumbra.
+		if ( !Rendering_to_env ) {
+			light_add_directional(&sun_dir, idx, !bm->glare, bm->i, bm->r, bm->g, bm->b,
+				sun_angular_radius_tangent(bm, Suns[idx].scale_x, Suns[idx].angular_size));
+		}
 
 		// if supernova
 		if ( supernova_active() && (idx == 0) )
@@ -2449,6 +2573,20 @@ int stars_find_bitmap(const char *name)
 	return -1;
 }
 
+// The mission-side list entry and the in-world instance carry the same fields, so keeping the
+// copy in one place is what stops the three call sites drifting apart. angular_size is only
+// meaningful for suns, but copying it for bitmaps too is harmless and keeps every caller
+// identical -- which beats being selectively correct in a way no reader can verify.
+static void starfield_copy_entry_to_instance(const starfield_list_entry *sle, starfield_bitmap_instance &sbi)
+{
+	sbi.ang = sle->ang;
+	sbi.scale_x = sle->scale_x;
+	sbi.scale_y = sle->scale_y;
+	sbi.div_x = sle->div_x;
+	sbi.div_y = sle->div_y;
+	sbi.angular_size = sle->angular_size;
+}
+
 // lookup a sun by bitmap filename, return index or -1 on fail
 int stars_find_sun(const char *name)
 {
@@ -2481,6 +2619,7 @@ void stars_get_data(bool is_sun, int idx, starfield_list_entry& sle)
 	sle.div_y = item.div_y;
 	sle.scale_x = item.scale_x;
 	sle.scale_y = item.scale_y;
+	sle.angular_size = item.angular_size;
 }
 
 void stars_set_data(bool is_sun, int idx, starfield_list_entry& sle)
@@ -2497,6 +2636,7 @@ void stars_set_data(bool is_sun, int idx, starfield_list_entry& sle)
 	item.div_y = sle.div_y;
 	item.scale_x = sle.scale_x;
 	item.scale_y = sle.scale_y;
+	item.angular_size = sle.angular_size;
 
 	// this is necessary when modifying bitmaps, but not when modifying suns
 	if (!is_sun)
@@ -2512,13 +2652,7 @@ int stars_add_sun_entry(starfield_list_entry *sun_ptr)
 	Assert(sun_ptr != NULL);
 
 	// copy information
-	sbi.ang.p = sun_ptr->ang.p;
-	sbi.ang.b = sun_ptr->ang.b;
-	sbi.ang.h = sun_ptr->ang.h;
-	sbi.scale_x = sun_ptr->scale_x;
-	sbi.scale_y = sun_ptr->scale_y;
-	sbi.div_x = sun_ptr->div_x;
-	sbi.div_y = sun_ptr->div_y;
+	starfield_copy_entry_to_instance(sun_ptr, sbi);
 
 	int idx = stars_find_sun(sun_ptr->filename);
 
@@ -2608,13 +2742,7 @@ int stars_add_bitmap_entry(starfield_list_entry *sle)
 	Assert(sle != NULL);
 
 	// copy information
-	sbi.ang.p = sle->ang.p;
-	sbi.ang.b = sle->ang.b;
-	sbi.ang.h = sle->ang.h;
-	sbi.scale_x = sle->scale_x;
-	sbi.scale_y = sle->scale_y;
-	sbi.div_x = sle->div_x;
-	sbi.div_y = sle->div_y;
+	starfield_copy_entry_to_instance(sle, sbi);
 
 	idx = stars_find_bitmap(sle->filename);
 
@@ -2876,13 +3004,7 @@ void stars_modify_entry_FRED(int index, const char *name, starfield_list_entry *
 	Assert( sbi_new != NULL );
 
     // copy information
-    sbi.ang.p = sbi_new->ang.p;
-	sbi.ang.b = sbi_new->ang.b;
-	sbi.ang.h = sbi_new->ang.h;
-	sbi.scale_x = sbi_new->scale_x;
-	sbi.scale_y = sbi_new->scale_y;
-	sbi.div_x = sbi_new->div_x;
-	sbi.div_y = sbi_new->div_y;
+	starfield_copy_entry_to_instance(sbi_new, sbi);
 
 	if (is_a_sun) {
 		idx = stars_find_sun((char*)name);

code/starfield/starfield.h

@@ -29,11 +29,35 @@
 
 
 // starfield list
+// A sun's apparent diameter, in degrees. Every layer that can supply one -- the mission file's
+// +AngularSize:, stars.tbl's $SunAngularSize:, and the LabUi session override -- uses this same
+// encoding, so "the first one that specifies a size wins" is all the precedence logic there is
+// (see sun_angular_radius_tangent() in starfield.cpp). Negative means that layer doesn't specify
+// a size; 0 asks for hard shadows outright. Only affects raytraced shadows.
+constexpr float SUN_ANGULAR_SIZE_UNSPECIFIED = -1.0f;
+
+// Sol's apparent diameter from Earth -- the one figure anyone has an intuition for, so it's what
+// the editors and the lab start from when switching a sun's size on.
+constexpr float SUN_ANGULAR_SIZE_SOL = 0.53f;
+
+// Well past anything plausible; the cap only exists to keep the value finite and non-negative.
+constexpr float SUN_ANGULAR_SIZE_MAX = 90.0f;
+
 typedef struct starfield_list_entry {
 	char filename[MAX_FILENAME_LEN];		// bitmap filename
 	float scale_x, scale_y;					// x and y scale
 	int div_x, div_y;						// # of x and y divisions
 	angles ang;								// angles from FRED
+	float angular_size;						// only for suns; see SUN_ANGULAR_SIZE_UNSPECIFIED
+
+	starfield_list_entry() : scale_x(1.0f), scale_y(1.0f), div_x(1), div_y(1),
+		angular_size(SUN_ANGULAR_SIZE_UNSPECIFIED)
+	{
+		filename[0] = '\0';
+		ang.p = 0.0f;
+		ang.b = 0.0f;
+		ang.h = 0.0f;
+	}
 } starfield_list_entry;
 
 // backgrounds
@@ -64,6 +88,11 @@ extern float Nmodel_alpha;
 extern bool Motion_debris_override;
 extern bool Motion_debris_enabled;
 
+// Session-only override (LabUi) of every sun's $SunAngularSize, in degrees of
+// apparent diameter -- sizes the penumbra of raytraced sun shadows. Negative
+// (the default) means no override: each sun uses its stars.tbl value.
+extern float Sun_angular_size_override;
+
 struct motion_debris_bitmaps {
 	int bm;
 	int nframes;

code/starfield/sun_disc.cpp

@@ -0,0 +1,222 @@
+#include "starfield/sun_disc.h"
+
+#include "bmpman/bmpman.h"
+#include "cfile/cfile.h"
+#include "ddsutils/ddsutils.h"
+#include "math/floating.h"
+#include "starfield/starfield.h"
+
+#include <cmath>
+
+// The sun quad is drawn with rad = 0.05f * scale_x (see stars_draw_sun()), and
+// g3_render_rect_screen_aligned_2d() sizes it so that rad is exactly the tangent of the
+// half-angle it subtends, independent of FOV, resolution and aspect ratio.
+static const float Sun_quad_tan_half_angle = 0.05f;
+
+// How much of that drawn size to believe. The drawn sun is an art decision rather than a
+// physical one: measured across the sun art of retail, the MediaVPs and several mods, the
+// emitting disc subtends a median of ~3.9x Sol's 0.53 degrees once the mission's +Scale: is
+// applied, and up to 26x in the worst retail mission. Taken literally that gives shadow edges
+// tens of metres wide. This scales the measurement so that median MediaVPs content -- what
+// nearly all modern mods ship -- lands near Sol; installs running retail's chunkier sun art
+// land about twice as soft.
+static const float Sun_derived_size_calibration = 0.25f;
+
+// Ceiling on a derived sun's apparent diameter, in degrees. Missions scale their suns freely
+// (retail's own missions go up to +Scale: 5.0), and penumbra width also decides how many rays
+// are needed to resolve it without grain -- shadows_rt_sample_count() caps at
+// RT_SHADOW_MAX_SAMPLES.
+static const float Sun_derived_max_diameter = 1.5f;
+
+float sun_disc_tangent_from_diameter(float degrees)
+{
+	return tanf(fl_radians(degrees) * 0.5f);
+}
+
+float sun_disc_tangent_from_fraction(float disc_fraction, float scale_x)
+{
+	if (disc_fraction <= 0.0f) {
+		return 0.0f;
+	}
+
+	return MIN(Sun_quad_tan_half_angle * scale_x * disc_fraction * Sun_derived_size_calibration,
+		sun_disc_tangent_from_diameter(Sun_derived_max_diameter));
+}
+
+void sun_disc_build_weights(const ubyte* pixels, int width, int height, int bytes_per_pixel, bool has_alpha,
+	SCP_vector<ubyte>& out_weights)
+{
+	Assertion(pixels != nullptr, "sun_disc_build_weights() called with no pixel data!");
+	Assertion(bytes_per_pixel == 3 || bytes_per_pixel == 4, "sun_disc_build_weights() only handles BGR and BGRA, got %d bytes per pixel!", bytes_per_pixel);
+
+	if (width <= 0 || height <= 0) {
+		out_weights.clear();
+		return;
+	}
+
+	const size_t num_pixels = static_cast<size_t>(width) * static_cast<size_t>(height);
+	out_weights.resize(num_pixels);
+
+	const bool use_alpha = has_alpha && (bytes_per_pixel == 4);
+
+	for (size_t i = 0; i < num_pixels; i++) {
+		const ubyte* px = pixels + (i * static_cast<size_t>(bytes_per_pixel));
+
+		// channel order doesn't matter to the maximum, so this works for both BGR and RGB
+		ubyte weight = MAX(px[0], MAX(px[1], px[2]));
+
+		if (use_alpha) {
+			weight = static_cast<ubyte>((static_cast<int>(weight) * static_cast<int>(px[3])) / 255);
+		}
+
+		out_weights[i] = weight;
+	}
+}
+
+void sun_disc_build_weights_16(const ubyte* pixels, int width, int height, bool has_alpha,
+	SCP_vector<ubyte>& out_weights)
+{
+	Assertion(pixels != nullptr, "sun_disc_build_weights_16() called with no pixel data!");
+
+	if (width <= 0 || height <= 0) {
+		out_weights.clear();
+		return;
+	}
+
+	const size_t num_pixels = static_cast<size_t>(width) * static_cast<size_t>(height);
+	out_weights.resize(num_pixels);
+
+	// bm_get_components() reads through whichever format bmpman currently has selected, and
+	// bm_load_image_data() leaves that on the screen format, so point it at the texture format
+	// for the duration -- the same select/restore bmpman does around its own loaders
+	BM_SELECT_TEX_FORMAT();
+
+	for (size_t i = 0; i < num_pixels; i++) {
+		ubyte r = 0;
+		ubyte g = 0;
+		ubyte b = 0;
+		ubyte a = 1;
+
+		bm_get_components(const_cast<ubyte*>(pixels + (i * 2)), &r, &g, &b, has_alpha ? &a : nullptr);
+
+		// the texture format only carries one bit of alpha (Gr_t_alpha), and bm_get_components()
+		// hands it back as 0 or 1 rather than 0-255, so it masks rather than scales. The colour
+		// channels are 5 bits each, so weights off this path are quantized to 1/31 -- coarser
+		// than the 8-bit paths, but far finer than the measurement needs.
+		out_weights[i] = (has_alpha && (a == 0)) ? static_cast<ubyte>(0) : MAX(r, MAX(g, b));
+	}
+
+	BM_SELECT_SCREEN_FORMAT();
+}
+
+float sun_disc_fraction_from_weights(const ubyte* weights, int width, int height)
+{
+	if ((weights == nullptr) || (width <= 0) || (height <= 0)) {
+		return 0.0f;
+	}
+
+	const size_t num_pixels = static_cast<size_t>(width) * static_cast<size_t>(height);
+
+	ubyte peak = 0;
+	for (size_t i = 0; i < num_pixels; i++) {
+		if (weights[i] > peak) {
+			peak = weights[i];
+		}
+	}
+
+	// blank or near-blank art has no disc to measure
+	if (peak < SUN_DISC_MIN_PEAK_WEIGHT) {
+		return 0.0f;
+	}
+
+	const auto cutoff = static_cast<ubyte>(std::ceil(SUN_DISC_THRESHOLD * static_cast<float>(peak)));
+
+	size_t disc_pixels = 0;
+	for (size_t i = 0; i < num_pixels; i++) {
+		if (weights[i] >= cutoff) {
+			disc_pixels++;
+		}
+	}
+
+	if (disc_pixels == 0) {
+		return 0.0f;
+	}
+
+	const float radius = fl_sqrt(static_cast<float>(disc_pixels) / PI);
+	const float half_edge = 0.5f * static_cast<float>(MIN(width, height));
+
+	// a bitmap lit all the way into its corners measures slightly over 1; the disc still
+	// can't be bigger than the quad it is drawn on
+	return MIN(radius / half_edge, 1.0f);
+}
+
+float sun_disc_measure_bitmap(int bitmap_handle)
+{
+	if (bitmap_handle < 0) {
+		return -1.0f;
+	}
+
+	const bool has_alpha = bm_has_alpha_channel(bitmap_handle);
+
+	int width = 0;
+	int height = 0;
+	SCP_vector<ubyte> weights;
+
+	if (bm_is_compressed(bitmap_handle)) {
+		// bm_lock() hands back block-compressed data as-is whenever the renderer supports
+		// S3TC/BPTC (see bm_lock_dds()), so this path has to go around bmpman and decompress
+		// the file itself. Sun art really does ship compressed, so it isn't an edge case.
+		const char* filename = bm_get_image_filename(bitmap_handle);
+
+		if ((filename == nullptr) || (*filename == '\0')) {
+			return -1.0f;
+		}
+
+		SCP_vector<ubyte> pixels;
+		if (dds_decompress_top_mip_bgra(filename, CF_TYPE_ANY, &width, &height, pixels) != DDS_ERROR_NONE) {
+			return -1.0f;
+		}
+
+		sun_disc_build_weights(pixels.data(), width, height, 4, has_alpha, weights);
+	} else {
+		bitmap* bmp = bm_lock(bitmap_handle, 32, BMP_TEX_XPARENT);
+
+		if (bmp == nullptr) {
+			return -1.0f;
+		}
+
+		if (bmp->data == 0) {
+			// bm_lock() took a reference before it failed to populate the data
+			bm_unlock(bitmap_handle);
+			return -1.0f;
+		}
+
+		// The requested bpp is a request, not a guarantee: bm_lock() ignores it for JPGs (always
+		// 24-bit BGR) and uncompressed DDS (whatever the file uses), and for anything already
+		// paged in it returns the data in the format page-in chose -- 16-bit for textures, see
+		// bm_page_in_stop(). Handle each layout rather than assuming the 32 we asked for.
+		width = bmp->w;
+		height = bmp->h;
+
+		const auto* pixels = reinterpret_cast<const ubyte*>(bmp->data);
+
+		if (bmp->bpp == 32) {
+			sun_disc_build_weights(pixels, width, height, 4, has_alpha, weights);
+		} else if (bmp->bpp == 24) {
+			sun_disc_build_weights(pixels, width, height, 3, false, weights);
+		} else if (bmp->bpp == 16) {
+			sun_disc_build_weights_16(pixels, width, height, has_alpha, weights);
+		} else {
+			bm_unlock(bitmap_handle);
+			return -1.0f;
+		}
+
+		bm_unlock(bitmap_handle);
+	}
+
+	if (weights.empty()) {
+		return -1.0f;
+	}
+
+	return sun_disc_fraction_from_weights(weights.data(), width, height);
+}

code/starfield/sun_disc.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include "globalincs/pstypes.h"
+
+// Measures how much of a sun bitmap is the emitting disc, as opposed to the glow/corona
+// painted around it. This is how a sun's apparent angular size is worked out when its table
+// entry doesn't give one outright, which is the usual case -- see sun_angular_radius_tangent()
+// in starfield.cpp for how the measurement becomes a shadow penumbra, and $SunAngularSize: in
+// stars.tbl for how a table opts out of it.
+
+// Pixels at or above this fraction of the brightest pixel count as part of the disc.
+// The measurement is only weakly sensitive to it -- across the shipped sun art of retail,
+// the MediaVPs and several mods, moving this to 0.5 rescales every bitmap by ~1.37x while
+// preserving their order almost exactly (Spearman rho 0.96) -- so it behaves as a constant
+// factor that the calibration in starfield.cpp absorbs, not as a per-bitmap judgement call.
+constexpr float SUN_DISC_THRESHOLD = 0.9f;
+
+// Sun bitmaps whose brightest pixel is dimmer than this are treated as having no disc at
+// all. Mods ship deliberately blank sun bitmaps (BtA's SunAntares*-BLANK, Blue Planet's
+// SunSolDummy) to get a light source without a visible sun, and without this floor the
+// threshold above would collapse to zero, match every pixel, and hand a sun that isn't
+// drawn at all the widest penumbra in the game.
+constexpr ubyte SUN_DISC_MIN_PEAK_WEIGHT = 8;
+
+/**
+ * @brief Reduces BGR(A) pixels to the per-pixel weight the disc measurement works on
+ *
+ * The weight is how much the texel actually contributes where the sun quad is drawn, which
+ * depends on how it is blended: sun bitmaps without an alpha channel are drawn additively
+ * and bitmaps with one are alpha blended (see material_determine_blend_mode()).
+ *
+ * @param pixels           BGR or BGRA pixel data, @a width * @a height * @a bytes_per_pixel bytes
+ * @param bytes_per_pixel  3 (BGR) or 4 (BGRA)
+ * @param has_alpha        whether the alpha channel is meaningful; ignored unless BGRA
+ * @param[out] out_weights resized to @a width * @a height
+ */
+void sun_disc_build_weights(const ubyte* pixels, int width, int height, int bytes_per_pixel, bool has_alpha,
+	SCP_vector<ubyte>& out_weights);
+
+/**
+ * @brief sun_disc_build_weights() for 16-bit texture-format pixels
+ *
+ * Bitmaps that went through bm_page_in_texture() are locked at 16 bpp (see bm_page_in_stop()),
+ * so anything but a compressed DDS is likely to be in the renderer's packed 16-bit texture
+ * format by the time a sun is drawn -- retail's PCX sun art included.
+ */
+void sun_disc_build_weights_16(const ubyte* pixels, int width, int height, bool has_alpha,
+	SCP_vector<ubyte>& out_weights);
+
+/**
+ * @brief Radius of the emitting disc, as a fraction of the drawn quad's half-width
+ *
+ * Coverage based: the disc's area is taken as the number of pixels at or above
+ * SUN_DISC_THRESHOLD of the brightest one, converted to the radius of a circle of that
+ * area. That survives off-centre discs, baked-in flare spikes and the halo tail, all of
+ * which a luminance-weighted radius would be dominated by.
+ *
+ * Normalized against the shorter edge, because that is the edge
+ * g3_render_rect_screen_aligned_2d() fits the quad to.
+ *
+ * @return the disc radius in [0, 1], or 0 if the bitmap has no measurable disc
+ */
+float sun_disc_fraction_from_weights(const ubyte* weights, int width, int height);
+
+/**
+ * @brief Tangent of the angular radius for an apparent diameter in degrees
+ *
+ * This is the form a directional light's source_radius takes -- see traceShadowRayCone() in
+ * shadows.sdr, where it sizes the shadow penumbra. 0 in, 0 out, i.e. hard shadows.
+ */
+float sun_disc_tangent_from_diameter(float degrees);
+
+/**
+ * @brief Same tangent, for a sun whose size is measured from its bitmap rather than given
+ *
+ * Turns a disc fraction into an angular size using the geometry of the drawn sun quad, then
+ * applies the calibration and ceiling that keep the result usable (see the constants in
+ * sun_disc.cpp for why a measured sun can't be believed literally).
+ *
+ * @param scale_x the mission's +Scale: for this sun instance
+ * @return the tangent, or 0 for a sun with no measurable disc
+ */
+float sun_disc_tangent_from_fraction(float disc_fraction, float scale_x);
+
+/**
+ * @brief Measures the disc fraction of a loaded sun bitmap
+ *
+ * Reads the bitmap's pixels on the CPU, so this is a one-shot operation -- callers must
+ * cache the result rather than calling it per frame. For animated sun bitmaps this measures
+ * the first frame, which is the handle bm_load_animation() returns.
+ *
+ * @return the disc fraction, or a negative value if the bitmap could not be read
+ */
+float sun_disc_measure_bitmap(int bitmap_handle);

code/tracing/FrameProfiler.cpp

@@ -3,6 +3,7 @@
 
 #include "FrameProfiler.h"
 
+#include "cmdline/cmdline.h"
 #include "globalincs/systemvars.h"
 
 using namespace tracing;
@@ -15,6 +16,9 @@ bool event_sorter(const trace_event& left, const trace_event& right) {
 }
 
 void process_begin(SCP_vector<profile_sample>& samples, const trace_event& evt) {
+	// Read the name through the id, not evt.category: the Category it names may already be dead
+	// (see trace_event::category_id).
+	const SCP_string category_name = Category::getNameById(evt.category_id);
 	int parent = -1;
 	for (int i = 0; i < (int) samples.size(); i++) {
 		if (!samples[i].open_profiles) {
@@ -30,7 +34,7 @@ void process_begin(SCP_vector<profile_sample>& samples, const trace_event& evt)
 	}
 
 	for (int i = 0; i < (int) samples.size(); i++) {
-		if (!strcmp(samples[i].name.c_str(), evt.category->getName()) && samples[i].parent == parent) {
+		if (samples[i].name == category_name && samples[i].parent == parent) {
 			// found the profile sample
 			samples[i].open_profiles++;
 			samples[i].profile_instances++;
@@ -43,7 +47,7 @@ void process_begin(SCP_vector<profile_sample>& samples, const trace_event& evt)
 	// create a new profile sample
 	profile_sample new_sample;
 
-	new_sample.name = SCP_string(evt.category->getName());
+	new_sample.name = category_name;
 	new_sample.open_profiles = 1;
 	new_sample.profile_instances = 1;
 	new_sample.accumulator = 0;
@@ -57,6 +61,9 @@ void process_begin(SCP_vector<profile_sample>& samples, const trace_event& evt)
 }
 
 void process_end(SCP_vector<profile_sample>& samples, const trace_event& evt) {
+	// Read the name through the id, not evt.category: the Category it names may already be dead
+	// (see trace_event::category_id).
+	const SCP_string category_name = Category::getNameById(evt.category_id);
 	uint num_parents = 0;
 	int child_of = -1;
 
@@ -69,7 +76,7 @@ void process_end(SCP_vector<profile_sample>& samples, const trace_event& evt) {
 	}
 
 	for (int i = 0; i < (int) samples.size(); i++) {
-		if (!strcmp(samples[i].name.c_str(), evt.category->getName()) && samples[i].parent == child_of) {
+		if (samples[i].name == category_name && samples[i].parent == child_of) {
 			int inner = 0;
 			int parent = -1;
 			uint64_t end_time = evt.timestamp;
@@ -120,7 +127,48 @@ void process_end(SCP_vector<profile_sample>& samples, const trace_event& evt) {
 
 namespace tracing {
 
-FrameProfiler::FrameProfiler() {
+uint64_t accumulate_self_times(const SCP_vector<trace_event>& events, SCP_vector<uint64_t>& self_time_by_id) {
+	self_time_by_id.assign(Category::getCount(), 0);
+
+	if (events.empty()) {
+		return 0;
+	}
+
+	uint64_t total = 0;
+	SCP_vector<int> open_stack; // category ids of currently-open scopes
+	open_stack.reserve(32);
+	uint64_t last_ts = events.front().timestamp;
+
+	for (const auto& evt : events) {
+		if (!open_stack.empty()) {
+			const uint64_t delta = evt.timestamp - last_ts;
+			self_time_by_id[static_cast<size_t>(open_stack.back())] += delta;
+			total += delta;
+		}
+		last_ts = evt.timestamp;
+
+		if (evt.category_id < 0 || evt.category_id >= static_cast<int>(self_time_by_id.size())) {
+			// Can't happen today (processEvent filters out null-category events, and every
+			// recorded id is in range at record time), but the category this id names may have
+			// been destroyed since (see trace_event::category_id) -- never trust it blindly, and
+			// keep last_ts advanced above so a stray event could never cause the next delta to
+			// span it.
+			continue;
+		}
+
+		if (evt.type == EventType::Begin) {
+			open_stack.push_back(evt.category_id);
+		} else if (evt.type == EventType::End) {
+			if (!open_stack.empty()) {
+				open_stack.pop_back();
+			}
+		}
+	}
+
+	return total;
+}
+
+FrameProfiler::FrameProfiler(std::int64_t mainThreadID) : _mainThreadID(mainThreadID) {
 
 }
 FrameProfiler::~FrameProfiler() {
@@ -137,12 +185,6 @@ void FrameProfiler::processEvent(const trace_event* event) {
 		return;
 	}
 
-	if (_mainThreadID == -1) {
-		// We need the ID of the main thread to filter out multi threaded events. We just assume that the first event
-		// of the main process we see is from the main thread. That should be a safe assumption.
-		_mainThreadID = event->tid;
-	}
-
 	if (event->tid != _mainThreadID) {
 		// Multithreaded events don't have a deterministic sequence and that confuses the old profiling system
 		return;
@@ -279,47 +321,70 @@ void FrameProfiler::dump_output(SCP_stringstream& out,
 SCP_string FrameProfiler::getContent() {
 	return content;
 }
+
+void FrameProfiler::build_overlay_snapshot(const SCP_vector<uint64_t>& self_time_by_id, uint64_t total) {
+	// Keep the id, not a Category pointer: a category that a script made through the Lua API
+	// tracing_category can be gone by now, but its name stays available through getNameById().
+	SCP_vector<std::pair<int, uint64_t>> sorted;
+	for (size_t id = 0; id < self_time_by_id.size(); id++) {
+		if (self_time_by_id[id] > 0) {
+			sorted.emplace_back(static_cast<int>(id), self_time_by_id[id]);
+		}
+	}
+	std::sort(sorted.begin(), sorted.end(),
+		[](const std::pair<int, uint64_t>& a, const std::pair<int, uint64_t>& b) {
+			return a.second > b.second;
+		});
+
+	overlaySnapshot.valid = true;
+	overlaySnapshot.total_nanosec = total;
+	overlaySnapshot.top_contributors.clear();
+	overlaySnapshot.other_nanosec = 0;
+
+	for (size_t i = 0; i < sorted.size(); i++) {
+		if (i < FRAME_OVERLAY_MAX_CONTRIBUTORS) {
+			overlaySnapshot.top_contributors.push_back({Category::getNameById(sorted[i].first), sorted[i].second});
+		} else {
+			overlaySnapshot.other_nanosec += sorted[i].second;
+		}
+	}
+}
 void FrameProfiler::processFrame() {
 
 	std::lock_guard<std::mutex> vectorGuard(_eventsMutex);
 
 	std::sort(_bufferedEvents.begin(), _bufferedEvents.end(), event_sorter);
 
-	SCP_stringstream stream;
+	// Overlay fast path: per-category self-time via a single stack walk (see accumulate_self_times).
+	// _selfTimeScratch is a member so the per-frame run reuses its allocation.
+	const uint64_t total = accumulate_self_times(_bufferedEvents, _selfTimeScratch);
+	build_overlay_snapshot(_selfTimeScratch, total);
 
-	SCP_vector<profile_sample> samples;
+	// Legacy on-screen text dump (-profile_frame_time). This still builds the full parent/child
+	// sample tree (process_begin/process_end) and the min/avg/max history, both O(n^2); only pay for
+	// it when that output is actually consumed, not for the overlay.
+	if (Cmdline_frame_profile) {
+		SCP_stringstream stream;
+		SCP_vector<profile_sample> samples;
 
-	bool start_found = false;
-	bool end_found = false;
-	uint64_t start_profile_time = 0;
-	uint64_t end_profile_time = 0;
-
-	for (auto& event : _bufferedEvents) {
-		if (!start_found) {
-			start_profile_time = event.timestamp;
-			start_found = true;
-		}
-		if (!end_found) {
-			end_profile_time = event.timestamp;
-			end_found = true;
+		for (auto& event : _bufferedEvents) {
+			switch (event.type) {
+				case EventType::Begin:
+					process_begin(samples, event);
+					break;
+				case EventType::End:
+					process_end(samples, event);
+					break;
+				default:
+					break;
+			}
 		}
 
-		switch (event.type) {
-			case EventType::Begin:
-				process_begin(samples, event);
-				break;
-			case EventType::End:
-				process_end(samples, event);
-				break;
-			default:
-				break;
-		}
+		dump_output(stream, 0, 0, samples);
+		content = stream.str();
 	}
+
 	_bufferedEvents.clear();
-
-	dump_output(stream, start_profile_time, end_profile_time, samples);
-
-	content = stream.str();
 }
 
 }

code/tracing/FrameProfiler.h

@@ -13,6 +13,16 @@
 
 namespace tracing {
 
+/**
+ * Computes the self time of each category for one frame of Begin/End events, sorted by event_id.
+ *
+ * @c self_time_by_id is resized to Category::getCount() and indexed by Category::getId(). Pass the
+ * same vector every frame to reuse its allocation.
+ *
+ * @return the sum of all self times, which is the total traced frame time.
+ */
+uint64_t accumulate_self_times(const SCP_vector<trace_event>& events, SCP_vector<uint64_t>& self_time_by_id);
+
 struct profile_sample_history {
 	bool valid;
 	//char name[256];
@@ -40,7 +50,13 @@ class FrameProfiler {
 
 	SCP_vector<profile_sample_history> history;
 
-	std::int64_t _mainThreadID = -1;
+	frame_overlay_snapshot overlaySnapshot;
+
+	// Reused across frames by accumulate_self_times() so the per-frame walk allocates nothing.
+	SCP_vector<uint64_t> _selfTimeScratch;
+
+	// The profiler keeps only events from this thread. Other threads have no deterministic event order.
+	std::int64_t _mainThreadID;
 
 	SCP_string content;
 
@@ -69,9 +85,15 @@ class FrameProfiler {
 					 uint64_t end_profile_time,
 					 SCP_vector<profile_sample>& samples);
 
+	/**
+	 * Builds the structured overlay snapshot (see frame_overlay_snapshot) from this frame's
+	 * per-category self-time. self_time_by_id is indexed by Category::getId(); total is the sum of
+	 * all self-times (i.e. total traced frame time). Called once per processFrame().
+	 */
+	void build_overlay_snapshot(const SCP_vector<uint64_t>& self_time_by_id, uint64_t total);
 
  public:
-	FrameProfiler();
+	explicit FrameProfiler(std::int64_t mainThreadID);
 	~FrameProfiler();
 
 	void processEvent(const trace_event* event);
@@ -79,6 +101,8 @@ class FrameProfiler {
 	void processFrame();
 
 	SCP_string getContent();
+
+	const frame_overlay_snapshot& getOverlaySnapshot() const { return overlaySnapshot; }
 };
 
 }

code/tracing/ProfilerOverlay.cpp

@@ -0,0 +1,454 @@
+//
+//
+
+#include "ProfilerOverlay.h"
+
+#include "tracing.h"
+
+#include "graphics/2d.h"
+#include "io/timer.h"
+#include "model/model.h"
+#include "object/object.h"
+#include "osapi/osapi.h"
+#include "parse/encrypt.h"
+#include "scripting/scripting.h"
+#include "sound/sound.h"
+
+// ImPlot's Plot*() functions are templates that get instantiated here (unlike ImGui's ordinary
+// function API), and their header-inline ImPool<ImPlotItem>::Add() uses memcpy on the
+// non-trivially-copyable ImPlotItem -- which trips pstypes.h's memcpy-safety macro. That macro
+// exists to catch accidental memcpy of non-POD engine types; ImPlotItem is third-party-internal
+// and already safe, so suppress it for just these headers.
+#pragma push_macro("memcpy")
+#undef memcpy
+#include "imgui.h"
+#include "implot.h"
+#pragma pop_macro("memcpy")
+
+#include <algorithm>
+#include <cstring>
+#include <numeric>
+
+namespace tracing {
+
+namespace {
+
+constexpr size_t HISTORY_SIZE = 300; // ~5s at 60 FPS
+constexpr double NANOSEC_PER_MS = 1'000'000.0;
+
+// std::queue does not permit iteration, but it keeps its container as a protected member. This
+// subclass gives the overlay read access to that container.
+class FrameTimeQueue : public SCP_queue<float> {
+  public:
+	const container_type& elements() const { return c; }
+};
+
+FrameTimeQueue History_ms;
+
+using HistoryContainer = FrameTimeQueue::container_type;
+
+// Wall-clock timestamp of the previous overlay frame, 0 when there is none yet. The frame time
+// in the history is the time between two overlay frames. It is not the traced self-time, which
+// leaves out every part of the frame that has no trace scope.
+uint64_t Last_frame_ns = 0;
+
+void push_history(float frame_ms) {
+	History_ms.push(frame_ms);
+	if (History_ms.size() > HISTORY_SIZE) {
+		History_ms.pop();
+	}
+}
+
+float history_average(const HistoryContainer& history) {
+	if (history.empty()) {
+		return 0.0f;
+	}
+	float sum = std::accumulate(history.begin(), history.end(), 0.0f);
+	return sum / static_cast<float>(history.size());
+}
+
+float history_median(const HistoryContainer& history) {
+	if (history.empty()) {
+		return 0.0f;
+	}
+
+	SCP_vector<float> sorted_copy(history.begin(), history.end());
+	size_t mid = sorted_copy.size() / 2;
+	std::nth_element(sorted_copy.begin(), sorted_copy.begin() + mid, sorted_copy.end());
+	float median = sorted_copy[mid];
+
+	if (sorted_copy.size() % 2 == 0) {
+		std::nth_element(sorted_copy.begin(), sorted_copy.begin() + mid - 1, sorted_copy.end());
+		median = (median + sorted_copy[mid - 1]) * 0.5f;
+	}
+
+	return median;
+}
+
+void draw_frametime_graph(const HistoryContainer& history) {
+	if (history.empty()) {
+		return;
+	}
+
+	if (ImPlot::BeginPlot("##frametime_ms",
+			ImVec2(-1, 90),
+			ImPlotFlags_NoMouseText | ImPlotFlags_NoLegend | ImPlotFlags_NoTitle)) {
+		ImPlot::SetupAxes(nullptr,
+			"ms",
+			ImPlotAxisFlags_NoTickLabels | ImPlotAxisFlags_NoGridLines,
+			ImPlotAxisFlags_AutoFit);
+		ImPlot::SetupAxisLimits(ImAxis_X1, 0, static_cast<double>(history.size()), ImPlotCond_Always);
+
+		// The getter reads the deque directly, so the graph needs no contiguous copy.
+		ImPlot::PlotLineG(
+			"frametime",
+			[](int idx, void* data) {
+				const auto& values = *static_cast<const HistoryContainer*>(data);
+				return ImPlotPoint(static_cast<double>(idx), static_cast<double>(values[static_cast<size_t>(idx)]));
+			},
+			const_cast<HistoryContainer*>(&history),
+			static_cast<int>(history.size()));
+
+		ImPlot::EndPlot();
+	}
+}
+
+/**
+ * Maps a category name to a stable color, so a given category keeps the same color across frames
+ * regardless of how its rank shifts in the breakdown. Uses an FNV-1a hash of the name to pick a
+ * hue; "Other" gets a fixed neutral grey (see draw_frame_budget_bar).
+ */
+ImU32 color_for_name(const char* name) {
+	const uint32_t hash = hash_fnv1a(name, strlen(name));
+	const float hue = static_cast<float>(hash % 360) / 360.0f;
+	return ImGui::ColorConvertFloat4ToU32(static_cast<ImVec4>(ImColor::HSV(hue, 0.55f, 0.95f)));
+}
+
+/**
+ * Draws a single 100%-stacked horizontal "frame budget" bar: one row whose width is split into
+ * segments proportional to each category's share of the frame's traced time (the snapshot's
+ * top contributors, see FRAME_OVERLAY_MAX_CONTRIBUTORS, + "Other"), followed by a legend with
+ * matching swatches, absolute ms and percentage. Cheaper than a pie chart -- it's a handful of
+ * ImDrawList rectangles with no ImPlot plot setup.
+ */
+void draw_frame_budget_bar(const frame_overlay_snapshot& snapshot) {
+	if (snapshot.total_nanosec == 0) {
+		return;
+	}
+
+	// +1 for "Other": snapshot.top_contributors holds at most FRAME_OVERLAY_MAX_CONTRIBUTORS
+	// entries (see tracing.h), so that's the real bound on how many segments can ever exist here.
+	constexpr int MAX_SEGMENTS = static_cast<int>(FRAME_OVERLAY_MAX_CONTRIBUTORS) + 1;
+	constexpr ImU32 OTHER_COLOR = IM_COL32(130, 130, 130, 255);
+
+	struct segment {
+		const char* name;
+		double pct;
+		float ms;
+		ImU32 color;
+	};
+
+	segment segments[MAX_SEGMENTS];
+	int count = 0;
+
+	const auto total = static_cast<double>(snapshot.total_nanosec);
+
+	// Self-defending against MAX_SEGMENTS regardless of caller bookkeeping, since this writes into
+	// a fixed-size array: silently drops anything past capacity rather than overflowing it.
+	auto add_segment = [&](const char* name, uint64_t self_nanosec, ImU32 color) {
+		if (count >= MAX_SEGMENTS) {
+			return;
+		}
+		segments[count].name = name;
+		segments[count].pct = 100.0 * static_cast<double>(self_nanosec) / total;
+		segments[count].ms = static_cast<float>(static_cast<double>(self_nanosec) / NANOSEC_PER_MS);
+		segments[count].color = color;
+		count++;
+	};
+
+	for (const auto& contributor : snapshot.top_contributors) {
+		add_segment(contributor.name.c_str(), contributor.self_nanosec, color_for_name(contributor.name.c_str()));
+	}
+	if (snapshot.other_nanosec > 0) {
+		add_segment("Other", snapshot.other_nanosec, OTHER_COLOR);
+	}
+
+	if (count == 0) {
+		return;
+	}
+
+	// The stacked bar.
+	ImDrawList* draw_list = ImGui::GetWindowDrawList();
+	const ImVec2 origin = ImGui::GetCursorScreenPos();
+	const float width = ImGui::GetContentRegionAvail().x;
+	constexpr float height = 22.0f;
+
+	draw_list->AddRectFilled(origin, ImVec2(origin.x + width, origin.y + height), IM_COL32(35, 35, 35, 255), 3.0f);
+
+	float x = origin.x;
+	for (int i = 0; i < count; i++) {
+		float seg_w = width * static_cast<float>(segments[i].pct / 100.0);
+		// Make sure the final segment reaches the right edge despite float rounding.
+		const float x_end = (i == count - 1) ? (origin.x + width) : (x + seg_w);
+		draw_list->AddRectFilled(ImVec2(x, origin.y), ImVec2(x_end, origin.y + height), segments[i].color);
+		x = x_end;
+	}
+	draw_list->AddRect(origin, ImVec2(origin.x + width, origin.y + height), IM_COL32(80, 80, 80, 255), 3.0f);
+
+	ImGui::Dummy(ImVec2(width, height));
+
+	// The legend.
+	for (int i = 0; i < count; i++) {
+		ImGui::ColorButton(segments[i].name,
+			ImGui::ColorConvertU32ToFloat4(segments[i].color),
+			ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_NoBorder,
+			ImVec2(12, 12));
+		ImGui::SameLine();
+		ImGui::Text("%s: %.2f ms (%.1f%%)", segments[i].name, segments[i].ms, segments[i].pct);
+	}
+}
+
+/**
+ * Draws whichever -gr_debug stat groups the active graphics backend collects (see
+ * gr_get_debug_stats()). Silently omits a group if its "valid" flag is unset, so this stays a
+ * no-op for backends (or builds) that don't populate a given group.
+ */
+void draw_graphics_debug_stats() {
+	gr_debug_stats stats = gr_get_debug_stats();
+
+	if (!stats.uniform_buffer_valid && !stats.draw_stats_valid) {
+		return;
+	}
+
+	ImGui::Separator();
+	ImGui::TextUnformatted("Graphics API stats (-gr_debug)");
+
+	if (stats.uniform_buffer_valid) {
+		ImGui::Text("Uniform buffer: " SIZE_T_ARG " / " SIZE_T_ARG " bytes used",
+			stats.uniform_buffer_used,
+			stats.uniform_buffer_size);
+	}
+
+	if (stats.draw_stats_valid) {
+		ImGui::Text("Draw calls: %d (%d indexed)", stats.draw_calls, stats.draw_indexed_calls);
+		ImGui::Text("Vertices: %d   Indices: %d", stats.total_vertices, stats.total_indices);
+		ImGui::Text("Material applies: %d (%d failed, %d no pipeline)",
+			stats.apply_material_calls,
+			stats.apply_material_failures,
+			stats.no_pipeline_skips);
+		ImGui::Text("Descriptor sets: %d   writes: %d   pipelines: " SIZE_T_ARG,
+			stats.descriptor_sets_allocated,
+			stats.descriptor_writes,
+			stats.pipeline_count);
+		if (stats.on_demand_texture_uploads > 0) {
+			ImGui::Text("On-demand texture uploads: %d", stats.on_demand_texture_uploads);
+		}
+	}
+}
+
+// Memory stats describe level-scope state (loaded models, live object pools, GPU heaps), not
+// per-frame state, so they're refreshed on an interval rather than walked every frame like the
+// timing data above -- that avoids perturbing the very frame cost this overlay measures.
+constexpr int MEMORY_STATS_REFRESH_INTERVAL_MS = 1000;
+
+bool Memory_stats_initialized = false;
+int Last_memory_stats_refresh_ms = 0;
+object_memory_stats Cached_object_memory_stats;
+model_memory_stats Cached_model_memory_stats;
+gr_memory_stats Cached_gr_memory_stats;
+os_memory_stats Cached_os_memory_stats;
+sound_memory_stats Cached_sound_memory_stats;
+scripting_memory_stats Cached_scripting_memory_stats;
+
+void refresh_memory_stats_if_needed() {
+	int now_ms = timer_get_milliseconds();
+	if (Memory_stats_initialized && (now_ms - Last_memory_stats_refresh_ms) < MEMORY_STATS_REFRESH_INTERVAL_MS) {
+		return;
+	}
+
+	Cached_object_memory_stats = obj_get_memory_stats();
+	Cached_model_memory_stats = model_get_memory_stats();
+	Cached_gr_memory_stats = gr_get_memory_stats();
+	Cached_os_memory_stats = os_get_memory_stats();
+	Cached_sound_memory_stats = snd_get_memory_stats();
+	Cached_scripting_memory_stats = scripting_get_memory_stats();
+
+	Last_memory_stats_refresh_ms = now_ms;
+	Memory_stats_initialized = true;
+}
+
+/**
+ * Formats a byte count with the largest unit that keeps at least one digit before the decimal point
+ * (e.g. "12.3 MB").
+ */
+SCP_string format_bytes(size_t bytes) {
+	constexpr double KB = 1024.0;
+	constexpr double MB = KB * 1024.0;
+	constexpr double GB = MB * 1024.0;
+
+	char buf[32];
+	if (auto b = static_cast<double>(bytes); b >= GB) {
+		snprintf(buf, sizeof(buf), "%.2f GB", b / GB);
+	} else if (b >= MB) {
+		snprintf(buf, sizeof(buf), "%.2f MB", b / MB);
+	} else if (b >= KB) {
+		snprintf(buf, sizeof(buf), "%.2f KB", b / KB);
+	} else {
+		snprintf(buf, sizeof(buf), SIZE_T_ARG " B", bytes);
+	}
+
+	return { buf };
+}
+
+/**
+ * Draws pool occupancy (used / max) for the object, ship, and weapon pools. These are fixed-size
+ * static arrays, so their byte footprint is a compile-time constant -- occupancy is the only
+ * signal worth showing.
+ */
+void draw_object_memory_stats() {
+	const object_memory_stats& stats = Cached_object_memory_stats;
+
+	ImGui::Separator();
+	ImGui::TextUnformatted("Object Management");
+	ImGui::Text("Objects: %d / %d (peak %d)", stats.objects_used, stats.objects_max, stats.objects_peak);
+	ImGui::Text("Ships:   %d / %d", stats.ships_used, stats.ships_max);
+	ImGui::Text("Weapons: %d / %d", stats.weapons_used, stats.weapons_max);
+}
+
+/**
+ * Draws model and texture memory usage. The GPU-heap numbers (live, reflects frees as models
+ * unload) and the per-model summed numbers (from currently loaded models) are two different views
+ * of related-but-not-identical data and are deliberately not added together into a single total.
+ */
+void draw_asset_memory_stats() {
+	const model_memory_stats& model_stats = Cached_model_memory_stats;
+	const gr_memory_stats& gr_stats = Cached_gr_memory_stats;
+
+	if (!model_stats.valid && !gr_stats.model_heap_valid && !gr_stats.locked_bitmap_ram_valid) {
+		return;
+	}
+
+	ImGui::Separator();
+	ImGui::TextUnformatted("Assets");
+
+	if (model_stats.valid) {
+		ImGui::Text("Models loaded: %d", model_stats.model_count);
+		ImGui::Text("  Vertex data: %s   Index data: %s   BSP/collision: %s",
+			format_bytes(model_stats.vertex_bytes).c_str(),
+			format_bytes(model_stats.index_bytes).c_str(),
+			format_bytes(model_stats.bsp_data_bytes).c_str());
+	}
+
+	if (gr_stats.locked_bitmap_ram_valid) {
+		ImGui::Text("Bitmaps (locked): %s", format_bytes(gr_stats.locked_bitmap_ram_bytes).c_str());
+	}
+
+	if (gr_stats.model_heap_valid) {
+		ImGui::Text("GPU model vertex heap: %s / %s",
+			format_bytes(gr_stats.model_vertex_heap_used).c_str(),
+			format_bytes(gr_stats.model_vertex_heap_size).c_str());
+		ImGui::Text("GPU model index heap:  %s / %s",
+			format_bytes(gr_stats.model_index_heap_used).c_str(),
+			format_bytes(gr_stats.model_index_heap_size).c_str());
+	}
+
+	if (gr_stats.gpu_purpose_valid) {
+		ImGui::Text("GPU textures: %s   geometry: %s   render targets: %s",
+			format_bytes(gr_stats.gpu_texture_bytes).c_str(),
+			format_bytes(gr_stats.gpu_geometry_bytes).c_str(),
+			format_bytes(gr_stats.gpu_render_target_bytes).c_str());
+	}
+}
+
+/**
+ * Draws the process-wide resident set size (RSS), when the platform supports querying it. This
+ * already includes every other row in this panel -- the engine heap, the Lua heap, the OpenAL
+ * buffers below, and the driver's own mappings for the GPU rows above -- so it's shown on its own
+ * rather than folded into any subsystem total.
+ */
+void draw_process_memory_stats() {
+	const os_memory_stats& stats = Cached_os_memory_stats;
+	if (!stats.valid) {
+		return;
+	}
+
+	ImGui::Separator();
+	ImGui::Text("Process (RSS): %s", format_bytes(stats.resident_bytes).c_str());
+}
+
+/**
+ * Draws memory usage for the audio and scripting subsystems. The audio number is buffer bytes
+ * handed to OpenAL, not an FSO heap allocation, so it's a lower bound rather than an exact figure.
+ */
+void draw_subsystem_memory_stats() {
+	const sound_memory_stats& sound_stats = Cached_sound_memory_stats;
+	const scripting_memory_stats& script_stats = Cached_scripting_memory_stats;
+
+	ImGui::Separator();
+	ImGui::TextUnformatted("Subsystems");
+	ImGui::Text("Audio buffers: %s", format_bytes(sound_stats.audio_buffer_bytes).c_str());
+	if (script_stats.valid) {
+		ImGui::Text("Lua heap: %s", format_bytes(script_stats.lua_heap_bytes).c_str());
+	}
+}
+
+} // namespace
+
+void profiler_overlay_frame() {
+	if (!frame_profiling_active()) {
+		History_ms = {};
+		Last_frame_ns = 0;
+		return;
+	}
+
+	frame_profile_process_frame();
+
+	const frame_overlay_snapshot& snapshot = get_frame_profiler_overlay_snapshot();
+	const uint64_t now_ns = timer_get_nanoseconds();
+	if (Last_frame_ns != 0) {
+		push_history(static_cast<float>(static_cast<double>(now_ns - Last_frame_ns) / NANOSEC_PER_MS));
+	}
+	Last_frame_ns = now_ns;
+
+	gr_imgui_begin_frame();
+	if (!gr_imgui_frame_active()) {
+		// No ImGui backend on this renderer (standalone server) — nothing to draw into.
+		return;
+	}
+
+	ImGui::SetNextWindowPos(ImVec2(20, 20), ImGuiCond_FirstUseEver);
+	ImGui::SetNextWindowSize(ImVec2(380, 480), ImGuiCond_FirstUseEver);
+	ImGui::Begin("Frame Profiler", nullptr, ImGuiWindowFlags_NoFocusOnAppearing);
+
+	if (History_ms.elements().empty()) {
+		ImGui::TextUnformatted("Collecting data...");
+	} else {
+		float avg_ms = history_average(History_ms.elements());
+		float median_ms = history_median(History_ms.elements());
+
+		ImGui::Text("Avg: %.2f ms (%.0f FPS)   Median: %.2f ms",
+			avg_ms,
+			avg_ms > 0.0f ? 1000.0f / avg_ms : 0.0f,
+			median_ms);
+
+		draw_frametime_graph(History_ms.elements());
+
+		ImGui::Separator();
+
+		draw_frame_budget_bar(snapshot);
+	}
+
+	draw_graphics_debug_stats();
+
+	refresh_memory_stats_if_needed();
+	if (ImGui::CollapsingHeader("Memory", ImGuiTreeNodeFlags_DefaultOpen)) {
+		draw_process_memory_stats();
+		draw_object_memory_stats();
+		draw_asset_memory_stats();
+		draw_subsystem_memory_stats();
+	}
+
+	ImGui::End();
+}
+
+} // namespace tracing

code/tracing/ProfilerOverlay.h

@@ -0,0 +1,24 @@
+#pragma once
+
+/** @file
+ *  @ingroup tracing
+ */
+
+namespace tracing {
+
+/**
+ * Per-frame entry point for the ImGui frame profiler overlay, called once from gr_flip().
+ *
+ * Drains the frame profiler (see frame_profile_process_frame()), folds the wall-clock time since
+ * the previous overlay frame into the rolling history behind the graph/avg/median, and contributes the overlay window
+ * -- avg/median frametime, a scrolling frametime graph, a stacked frame-budget bar of the top
+ * traced categories by self-time, and the -gr_debug graphics stats -- to this frame's ImGui pass,
+ * opening one via gr_imgui_begin_frame() if no other consumer already has.
+ *
+ * No-op when frame profiling is disabled. Being the single per-frame driver is what keeps the
+ * profiler's event buffer bounded in every game state, so it must stay on the common flip path
+ * rather than being called per game state.
+ */
+void profiler_overlay_frame();
+
+}