D3D11: Migrate consumers from regs_generation to dirty[] groups

Replace the monolithic regs_generation counter with fine-grained dirty
group generation counters throughout the HLE rendering pipeline:

- XbPixelShaderCompiler: Regs SRV upload still uses dirty[PGRAPH] (needs
  any-register sensitivity). Aux CB rebuild narrowed to check only
  SHADER + TEXTURE + BLEND + RASTERIZER groups.
- PixelShaderCache: PS JIT key build narrowed to the same 4 groups,
  skipping rebuilds triggered by unrelated register writes (e.g. VS
  constants, surface state).
- XbVertexShader: Migrated to dirty[PROGRAM] generation counter with
  per-consumer s_Last*Gen tracking (replacing boolean clear pattern).
- HostRender/HostSync/Backend_D3D11: Updated remaining consumers.

Assign NV2A_DIRTY_SHADER to NV097_SET_SPECULAR_ENABLE (was NONE) since
the aux CB and PS JIT read CSV0_C.SPECULAR_ENABLE for final combiner
synthesis.

Remove regs_generation field from PGRAPHState entirely.

Author: PatrickvL

doc/pgraph_migration_status.md

@@ -107,6 +107,6 @@ Draw callbacks registered in XbPushBuffer.cpp `CxbxInitD3D11Renderer()`:
 
 - Light enable mask: `pg->regs[NV_PGRAPH_CSV0_D / 4] & NV_PGRAPH_CSV0_D_LIGHTS` (2 bits/light)
 - NV2A type mapping: 1(INFINITE)→3(DIRECTIONAL), 2(LOCAL)→1(POINT), 3(SPOT)→2(SPOT)
-- Colors from `pg->ltctxb[]` (pre-multiplied by material by Xbox D3D runtime)
+- Colors from `pg->xf.ltctxb[]` (pre-multiplied by material by Xbox D3D runtime)
 - Material forced to white — ltctxb already contains light×material product
-- Scene ambient from `pg->ltctxa[FR_AMB]` / `pg->ltctxa[BR_AMB]`
+- Scene ambient from `pg->xf.ltctxa[FR_AMB]` / `pg->xf.ltctxa[BR_AMB]`

src/core/hle/D3D8/Rendering/Backend/Backend_D3D11.cpp

@@ -182,7 +182,7 @@ ID3D11ShaderResourceView  *g_pD3D11PGRegsSRV = nullptr;          // SRV for g_PG
 bool                       g_bUseVSInterpreter = true; // default on — ubershader path
 ID3D11VertexShader        *g_pD3D11VSInterpreterVS = nullptr;
 ID3DBlob                  *g_pD3D11VSInterpreterBytecode = nullptr; // kept for input layout creation
-ID3D11Buffer              *g_pD3D11XFPRBuf = nullptr;           // XFPR (Transform Program RAM) structured buffer — pg->program_data[]
+ID3D11Buffer              *g_pD3D11XFPRBuf = nullptr;           // XFPR (Transform Program RAM) structured buffer — pg->xf.xfpr[]
 ID3D11ShaderResourceView  *g_pD3D11XFPRSRV = nullptr;           // SRV for g_XFPR : register(t5)
 
 // ******************************************************************

src/core/hle/D3D8/Rendering/Backend/Backend_D3D11_Internal.h

@@ -130,7 +130,7 @@ extern ID3D11ShaderResourceView  *g_pD3D11PGRegsSRV;            // SRV for g_PGR
 extern bool                       g_bUseVSInterpreter;
 extern ID3D11VertexShader        *g_pD3D11VSInterpreterVS;
 extern ID3DBlob                  *g_pD3D11VSInterpreterBytecode;
-extern ID3D11Buffer              *g_pD3D11XFPRBuf;              // XFPR (Transform Program RAM) StructuredBuffer — pg->program_data[]
+extern ID3D11Buffer              *g_pD3D11XFPRBuf;              // XFPR (Transform Program RAM) StructuredBuffer — pg->xf.xfpr[]
 extern ID3D11ShaderResourceView  *g_pD3D11XFPRSRV;              // SRV for g_XFPR : register(t5)
 
 // VS interpreter instruction field constants — shared with HLSL.

src/core/hle/D3D8/Rendering/Backend/Backend_D3D11_State.cpp

@@ -522,10 +522,9 @@ void CxbxD3D11UpdateViewportFromPGRAPH(PGRAPHState *pg)
 	// The calculation is cheap (a few floats + two D3D11 calls).
 
 	// Read viewport offset and scale from XFCTX constants
-	float vpoff[4], vpscl[4];
-	for (int i = 0; i < 4; i++) {
-		std::memcpy(&vpoff[i], &pg->vsh_constants[NV_IGRAPH_XF_XFCTX_VPOFF][i], sizeof(float));
-		std::memcpy(&vpscl[i], &pg->vsh_constants[NV_IGRAPH_XF_XFCTX_VPSCL][i], sizeof(float));
+	float vpscl[2];
+	for (int i = 0; i < 2; i++) {
+		std::memcpy(&vpscl[i], &pg->xf.xfctx[NV_IGRAPH_XF_XFCTX_VPSCL][i], sizeof(float));
 	}
 
 	// If the viewport scale constants are zero, PGRAPH hasn't been programmed

src/core/hle/D3D8/Rendering/Backend/Shading/PixelShaderCache.cpp

@@ -875,13 +875,16 @@ ID3D11PixelShader* PixelShaderCache::GetShader(ID3D11Device* pDevice)
 
     PGRAPHState* pg = &g_NV2A->GetDeviceState()->pgraph;
 
-    // Fast path: if PGRAPH registers haven't changed since last call,
-    // the combiner topology is identical — return cached result directly
-    // without rebuilding the key or hashing.
+    // Fast path: if none of the relevant dirty groups changed since last
+    // call, the combiner topology is identical — return cached result
+    // directly without rebuilding the key or hashing.
+    // PS JIT reads SHADER, TEXTURE, BLEND, and RASTERIZER registers.
     static uint32_t s_LastPSRegsGen = ~0u;
     static ID3D11PixelShader* s_LastPSResult = nullptr;
     static PSJITKey s_LastKey = {};
-    if (pg->regs_generation == s_LastPSRegsGen)
+    uint32_t psRegsGen = pg->dirty[NV2A_DIRTY_SHADER] + pg->dirty[NV2A_DIRTY_TEXTURE]
+                       + pg->dirty[NV2A_DIRTY_BLEND] + pg->dirty[NV2A_DIRTY_RASTERIZER];
+    if (psRegsGen == s_LastPSRegsGen)
         return s_LastPSResult;
 
     // Capture current state — read directly from PGRAPH registers
@@ -926,10 +929,10 @@ ID3D11PixelShader* PixelShaderCache::GetShader(ID3D11Device* pDevice)
     key.alphaKill[3] = aux.AlphaKill.w;
 
     // Second fast path: if the key matches the last one (combiner state unchanged
-    // despite regs_generation bumping from non-combiner register writes like VS
-    // constants), skip the expensive hash + mutex + map lookup.
+    // despite dirty groups bumping from non-combiner register writes),
+    // skip the expensive hash + mutex + map lookup.
     if (memcmp(&key, &s_LastKey, sizeof(PSJITKey)) == 0) {
-        s_LastPSRegsGen = pg->regs_generation;
+        s_LastPSRegsGen = psRegsGen;
         return s_LastPSResult;
     }
 
@@ -940,7 +943,7 @@ ID3D11PixelShader* PixelShaderCache::GetShader(ID3D11Device* pDevice)
         auto it = g_PSJITCache.find(hash);
         if (it != g_PSJITCache.end()) {
             s_LastKey = key;
-            s_LastPSRegsGen = pg->regs_generation;
+            s_LastPSRegsGen = psRegsGen;
             s_LastPSResult = it->second.pPS;
             return s_LastPSResult; // nullptr = known failure
         }
@@ -963,7 +966,7 @@ ID3D11PixelShader* PixelShaderCache::GetShader(ID3D11Device* pDevice)
             std::lock_guard<std::mutex> lock(g_PSJITMutex);
             g_PSJITCache[hash] = { pPS };
             s_LastKey = key;
-            s_LastPSRegsGen = pg->regs_generation;
+            s_LastPSRegsGen = psRegsGen;
             s_LastPSResult = pPS;
             return pPS;
         }
@@ -993,7 +996,7 @@ ID3D11PixelShader* PixelShaderCache::GetShader(ID3D11Device* pDevice)
         std::lock_guard<std::mutex> lock(g_PSJITMutex);
         g_PSJITCache[hash] = { nullptr };
         s_LastKey = key;
-        s_LastPSRegsGen = pg->regs_generation;
+        s_LastPSRegsGen = psRegsGen;
         s_LastPSResult = nullptr;
         return nullptr;
     }
@@ -1009,7 +1012,7 @@ ID3D11PixelShader* PixelShaderCache::GetShader(ID3D11Device* pDevice)
         std::lock_guard<std::mutex> lock(g_PSJITMutex);
         g_PSJITCache[hash] = { nullptr };
         s_LastKey = key;
-        s_LastPSRegsGen = pg->regs_generation;
+        s_LastPSRegsGen = psRegsGen;
         s_LastPSResult = nullptr;
         return nullptr;
     }
@@ -1024,7 +1027,7 @@ ID3D11PixelShader* PixelShaderCache::GetShader(ID3D11Device* pDevice)
     std::lock_guard<std::mutex> lock(g_PSJITMutex);
     g_PSJITCache[hash] = { pPS };
     s_LastKey = key;
-    s_LastPSRegsGen = pg->regs_generation;
+    s_LastPSRegsGen = psRegsGen;
     s_LastPSResult = pPS;
     return pPS;
 }

src/core/hle/D3D8/Rendering/HostRender.cpp

@@ -528,7 +528,7 @@ void CxbxUpdateHostViewPortOffsetAndScaleConstants()
 	// With draws going through pfifo, the PGRAPH values ARE the source of
 	// truth — they are written before the draw in the push buffer and
 	// processed sequentially by the puller.  CxbxUpdateHostVertexShaderConstants
-	// already uploads them from pg->vsh_constants[58/59].
+	// already uploads them from pg->xf.xfctx[58/59].
 	//
 	// TODO: Re-enable this overwrite if HLE draw patches are restored.
 	// Test Case: GTA III, Soldier of Fortune II (needed when HLE draws are active)
@@ -673,7 +673,7 @@ void UpdateFixedFunctionVertexShaderState()
 		// Helper: direct-copy a 4x4 matrix from vsh_constants[base..base+3] — NO transpose
 		auto ReadXFCTXMatrix = [&](D3DXMATRIX* pDst, int base) {
 			for (int row = 0; row < 4; row++) {
-				std::memcpy(&pDst->m[row][0], &pg->vsh_constants[base + row][0], 16);
+				std::memcpy(&pDst->m[row][0], &pg->xf.xfctx[base + row][0], 16);
 			}
 		};
 
@@ -685,7 +685,7 @@ void UpdateFixedFunctionVertexShaderState()
 		// Read viewport offset from PGRAPH XFCTX (half-pixel bias applied by Xbox runtime)
 		float vpoff[4];
 		for (int i = 0; i < 4; i++) {
-			std::memcpy(&vpoff[i], &pg->vsh_constants[NV_IGRAPH_XF_XFCTX_VPOFF][i], sizeof(float));
+			std::memcpy(&vpoff[i], &pg->xf.xfctx[NV_IGRAPH_XF_XFCTX_VPOFF][i], sizeof(float));
 		}
 
 		// NV2A FF pipeline: CMAT × position → screen-space coordinates (viewport baked in).
@@ -963,68 +963,68 @@ void UpdateFixedFunctionVertexShaderState()
 			// Diffuse color from ltctxb (3 floats stored as uint32_t bit patterns)
 			int base = NV_IGRAPH_XF_LTCTXB_L0_DIF + (int)i * 6;
 			pShaderLight->Diffuse = D3DXVECTOR4(
-				AsFloat(pg->ltctxb[base][0]),
-				AsFloat(pg->ltctxb[base][1]),
-				AsFloat(pg->ltctxb[base][2]),
+				AsFloat(pg->xf.ltctxb[base][0]),
+				AsFloat(pg->xf.ltctxb[base][1]),
+				AsFloat(pg->xf.ltctxb[base][2]),
 				1.0f);
 
 			// Specular color
 			bool SpecularEnable = (csv0c & NV_PGRAPH_CSV0_C_SPECULAR_ENABLE) != 0;
 			base = NV_IGRAPH_XF_LTCTXB_L0_SPC + (int)i * 6;
 			if (SpecularEnable) {
 				pShaderLight->Specular = D3DXVECTOR4(
-					AsFloat(pg->ltctxb[base][0]),
-					AsFloat(pg->ltctxb[base][1]),
-					AsFloat(pg->ltctxb[base][2]),
+					AsFloat(pg->xf.ltctxb[base][0]),
+					AsFloat(pg->xf.ltctxb[base][1]),
+					AsFloat(pg->xf.ltctxb[base][2]),
 					1.0f);
 			} else {
 				pShaderLight->Specular = D3DXVECTOR4(0, 0, 0, 0);
 			}
 
 			// Accumulate per-light ambient
 			base = NV_IGRAPH_XF_LTCTXB_L0_AMB + (int)i * 6;
-			LightAmbient.x += AsFloat(pg->ltctxb[base][0]);
-			LightAmbient.y += AsFloat(pg->ltctxb[base][1]);
-			LightAmbient.z += AsFloat(pg->ltctxb[base][2]);
+			LightAmbient.x += AsFloat(pg->xf.ltctxb[base][0]);
+			LightAmbient.y += AsFloat(pg->xf.ltctxb[base][1]);
+			LightAmbient.z += AsFloat(pg->xf.ltctxb[base][2]);
 
 			// Direction (for directional lights — already in view-space, normalized)
 			pShaderLight->DirectionVN = D3DXVECTOR3(
-				pg->light_infinite_direction[i][0],
-				pg->light_infinite_direction[i][1],
-				pg->light_infinite_direction[i][2]);
+				pg->light[i].infinite_direction[0],
+				pg->light[i].infinite_direction[1],
+				pg->light[i].infinite_direction[2]);
 
 			// Position (for point/spot lights — already in view-space)
 			pShaderLight->PositionV = D3DXVECTOR3(
-				pg->light_local_position[i][0],
-				pg->light_local_position[i][1],
-				pg->light_local_position[i][2]);
+				pg->light[i].local_position[0],
+				pg->light[i].local_position[1],
+				pg->light[i].local_position[2]);
 
 			// Attenuation
 			pShaderLight->Attenuation = D3DXVECTOR3(
-				pg->light_local_attenuation[i][0],
-				pg->light_local_attenuation[i][1],
-				pg->light_local_attenuation[i][2]);
+				pg->light[i].local_attenuation[0],
+				pg->light[i].local_attenuation[1],
+				pg->light[i].local_attenuation[2]);
 
 			// Range (stored in ltc1)
-			pShaderLight->Range = AsFloat(pg->ltc1[NV_IGRAPH_XF_LTC1_r0 + i][0]);
+			pShaderLight->Range = AsFloat(pg->xf.ltc1[NV_IGRAPH_XF_LTC1_r0 + i][0]);
 
 			// Spot parameters from ltctxa
 			int spotBase = NV_IGRAPH_XF_LTCTXA_L0_K + (int)i * 2;
-			pShaderLight->Falloff = AsFloat(pg->ltctxa[spotBase][2]); // falloff stored in K[2]
-			pShaderLight->CosHalfPhi = AsFloat(pg->ltctxa[spotBase][0]);
-			pShaderLight->SpotIntensityDivisor = AsFloat(pg->ltctxa[spotBase][1]);
+			pShaderLight->Falloff = AsFloat(pg->xf.ltctxa[spotBase][2]); // falloff stored in K[2]
+			pShaderLight->CosHalfPhi = AsFloat(pg->xf.ltctxa[spotBase][0]);
+			pShaderLight->SpotIntensityDivisor = AsFloat(pg->xf.ltctxa[spotBase][1]);
 		}
 
 		// Scene ambient from PGRAPH ltctxa[FR_AMB] (3 floats)
 		D3DXVECTOR4 SceneAmbient(
-			AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_FR_AMB][0]),
-			AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_FR_AMB][1]),
-			AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_FR_AMB][2]),
+			AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_FR_AMB][0]),
+			AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_FR_AMB][1]),
+			AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_FR_AMB][2]),
 			0.f);
 		D3DXVECTOR4 BackSceneAmbient(
-			AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_BR_AMB][0]),
-			AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_BR_AMB][1]),
-			AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_BR_AMB][2]),
+			AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_BR_AMB][0]),
+			AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_BR_AMB][1]),
+			AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_BR_AMB][2]),
 			0.f);
 
 		ffShaderState.TotalLightsAmbient.Front = (D3DXVECTOR3)(LightAmbient + SceneAmbient);
@@ -1034,8 +1034,8 @@ void UpdateFixedFunctionVertexShaderState()
 		// The shader computes (material * light), so white material preserves the pre-multiplied values.
 		// Emission is already baked into the scene ambient register (FR_AMB/BR_AMB) by the Xbox D3D runtime.
 		// Material alpha comes from NV097_SET_MATERIAL_ALPHA → ltctxa[CM_COL][3].
-		float materialAlpha     = AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_CM_COL][3]);
-		float backMaterialAlpha = AsFloat(pg->ltctxa[NV_IGRAPH_XF_LTCTXA_BCM_COL][3]);
+		float materialAlpha     = AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_CM_COL][3]);
+		float backMaterialAlpha = AsFloat(pg->xf.ltctxa[NV_IGRAPH_XF_LTCTXA_BCM_COL][3]);
 
 		ffShaderState.Materials[0].Diffuse  = D3DXVECTOR4(1, 1, 1, materialAlpha);
 		ffShaderState.Materials[0].Ambient  = D3DXVECTOR4(1, 1, 1, 1);
@@ -1045,17 +1045,17 @@ void UpdateFixedFunctionVertexShaderState()
 		// Reconstruct specular power from NV2A's 6 polynomial coefficients (LTC1).
 		// Front specular params: ltc1[l0][0..3] + ltc1[l0+1][0..1]
 		float frontParams[6];
-		for (int j = 0; j < 4; j++) frontParams[j]     = AsFloat(pg->ltc1[NV_IGRAPH_XF_LTC1_l0][j]);
-		for (int j = 0; j < 2; j++) frontParams[4 + j]  = AsFloat(pg->ltc1[NV_IGRAPH_XF_LTC1_l0 + 1][j]);
+		for (int j = 0; j < 4; j++) frontParams[j]     = AsFloat(pg->xf.ltc1[NV_IGRAPH_XF_LTC1_l0][j]);
+		for (int j = 0; j < 2; j++) frontParams[4 + j]  = AsFloat(pg->xf.ltc1[NV_IGRAPH_XF_LTC1_l0 + 1][j]);
 		ffShaderState.Materials[0].Power = ReconstructSpecularPower(frontParams);
 
 		ffShaderState.Materials[1] = ffShaderState.Materials[0]; // back material (start from front)
 		ffShaderState.Materials[1].Diffuse.w = backMaterialAlpha;
 
 		// Back specular params: ltc1[Bl0][0..3] + ltc1[Bl0+1][0..1]
 		float backParams[6];
-		for (int j = 0; j < 4; j++) backParams[j]     = AsFloat(pg->ltc1[NV_IGRAPH_XF_LTC1_Bl0][j]);
-		for (int j = 0; j < 2; j++) backParams[4 + j]  = AsFloat(pg->ltc1[NV_IGRAPH_XF_LTC1_Bl0 + 1][j]);
+		for (int j = 0; j < 4; j++) backParams[j]     = AsFloat(pg->xf.ltc1[NV_IGRAPH_XF_LTC1_Bl0][j]);
+		for (int j = 0; j < 2; j++) backParams[4 + j]  = AsFloat(pg->xf.ltc1[NV_IGRAPH_XF_LTC1_Bl0 + 1][j]);
 		ffShaderState.Materials[1].Power = ReconstructSpecularPower(backParams);
 	}
 

src/core/hle/D3D8/Rendering/HostSync.cpp

@@ -727,10 +727,10 @@ void CxbxUpdateHostVertexShaderConstants()
 		isXboxConstants = false;
 	}
 	else {
-		auto constant_floats = (float*)pg->vsh_constants;
+		auto constant_floats = (float*)pg->xf.xfctx;
 
 		if (isXboxConstants) {
-			CxbxUpdateDirtyVertexShaderConstants(constant_floats, pg->vsh_constants_dirty);
+			CxbxUpdateDirtyVertexShaderConstants(constant_floats, pg->xf.xfctx_dirty);
 		}
 		else {
 			CxbxSetVertexShaderConstantF(0, constant_floats, X_D3DVS_CONSTREG_COUNT);

src/core/hle/D3D8/XbPixelShaderCompiler.cpp

@@ -268,14 +268,14 @@ void CxbxD3D11UploadRCInterpreterState()
 	PGRAPHState *pg = &g_NV2A->GetDeviceState()->pgraph;
 
 	// --- Upload raw PGRAPH regs[] to the StructuredBuffer<uint> SRV ---
-	// Only re-upload when regs actually changed (generation counter bumped
+	// Only re-upload when regs actually changed (dirty generation bumped
 	// by nv097_dispatch_method on any register write).
 	// NOTE: Both JIT and interpreter shaders read dynamic constants (C0/C1,
 	// fog color, bump matrices) from this SRV at runtime, so upload is required.
 	{
 		static uint32_t s_LastRegsGeneration = ~0u;
-		if (pg->regs_generation != s_LastRegsGeneration) {
-			s_LastRegsGeneration = pg->regs_generation;
+		if (pg->dirty[NV2A_DIRTY_PGRAPH] != s_LastRegsGeneration) {
+			s_LastRegsGeneration = pg->dirty[NV2A_DIRTY_PGRAPH];
 			CxbxD3D11UpdateDynamicBuffer(g_pD3D11PGRegsBuf, pg->regs, sizeof(pg->regs));
 		}
 	}
@@ -289,12 +289,15 @@ void CxbxD3D11UploadRCInterpreterState()
 	}
 
 	// --- Build the auxiliary cbuffer (software-computed fields only) ---
-	// Skip rebuild if regs_generation hasn't changed (aux depends only on regs[])
+	// Skip rebuild if none of the relevant dirty groups changed.
+	// Aux CB reads only SHADER, TEXTURE, BLEND, and RASTERIZER registers.
 	{
 		static uint32_t s_LastAuxGeneration = ~0u;
-		if (pg->regs_generation == s_LastAuxGeneration)
+		uint32_t auxGen = pg->dirty[NV2A_DIRTY_SHADER] + pg->dirty[NV2A_DIRTY_TEXTURE]
+		                + pg->dirty[NV2A_DIRTY_BLEND] + pg->dirty[NV2A_DIRTY_RASTERIZER];
+		if (auxGen == s_LastAuxGeneration)
 			return; // Aux CB and regs SRV are still current
-		s_LastAuxGeneration = pg->regs_generation;
+		s_LastAuxGeneration = auxGen;
 	}
 	PSAuxCBLayout aux = {};