rsx: Fix shader interpreter variants generation

rpcs3/Emu/RSX/Program/ShaderInterpreter.cpp

@@ -5,54 +5,67 @@
 
 namespace program_common::interpreter
 {
-    std::vector<interpreter_variant_t> get_interpreter_variants()
+	void bitrange_foreach(u32 min, u32 max, std::function<void(u32)> func)
-    {
+	{
-        // Separable passes to fetch all possible variants
+		if (max <= min)
-        std::unordered_set<u32> fs_masks;
+		{
-        for (u32 fs_opt = COMPILER_OPT_FS_MIN, fs_opt_bit = fs_opt;
+			return;
-            fs_opt <= COMPILER_OPT_FS_MAX; fs_opt++, fs_opt_bit <<= 1)
+		}
-        {
-            if (fs_opt_bit & COMPILER_OPT_ALPHA_TEST_MASK)
-            {
-                continue;
-            }
 
-            fs_masks.insert(fs_opt);
+		const u32 shift = std::countr_zero(min);
-        }
+		const u32 a = min >> shift;
+		const u32 b = (max + max) >> shift;
 
-        // Now we add in the alpha testing variants for all fs variants.
+		for (u32 acc = a; acc < b; acc++)
-        // Only one alpha test type is usable at once
+		{
-        std::unordered_set<u32> fs_alpha_test_masks;
+			func(acc << shift);
-        for (u32 alpha_test_bit = COMPILER_OPT_ENABLE_ALPHA_TEST_GE;
+		}
-            alpha_test_bit <= COMPILER_OPT_ENABLE_ALPHA_TEST_NE;
+	}
-            alpha_test_bit <<= 1)
-        {
-            for (const auto& mask : fs_masks)
-            {
-                fs_alpha_test_masks.insert(mask | alpha_test_bit);
-            }
-        }
 
-        // VS
+	std::vector<interpreter_variant_t> get_interpreter_variants()
-        std::unordered_set<u32> vs_masks;
+	{
-        for (u32 vs_opt = COMPILER_OPT_VS_MIN; vs_opt <= COMPILER_OPT_VS_MAX; ++vs_opt)
+		// Separable passes to fetch all possible variants
-        {
+		std::unordered_set<u32> fs_masks;
-            vs_masks.insert(vs_opt);
+		fs_masks.insert(0);
-        }
+		bitrange_foreach(COMPILER_OPT_FS_MIN, COMPILER_OPT_FS_MAX, [&](u32 fs_opt)
+		{
+			fs_masks.insert(fs_opt);
+		});
 
-        // Merge all FS variants
+		// Now we add in the alpha testing variants for all fs variants.
-        fs_masks.merge(fs_alpha_test_masks);
+		// Only one alpha test type is usable at once
+		std::unordered_set<u32> fs_alpha_test_masks;
+		for (u32 alpha_test_bit = COMPILER_OPT_ENABLE_ALPHA_TEST_GE;
+			alpha_test_bit <= COMPILER_OPT_ENABLE_ALPHA_TEST_NE;
+			alpha_test_bit <<= 1)
+		{
+			for (const auto& mask : fs_masks)
+			{
+				fs_alpha_test_masks.insert(mask | alpha_test_bit);
+			}
+		}
 
-        // Prepare outputs
+		// VS
-        std::vector<interpreter_variant_t> results;
+		std::unordered_set<u32> vs_masks;
-        for (const auto& vs_opt : vs_masks)
+		vs_masks.insert(0);
-        {
+		bitrange_foreach(COMPILER_OPT_VS_MIN, COMPILER_OPT_VS_MAX, [&](u32 vs_opt)
-            for (const auto& fs_opt : fs_masks)
+		{
-            {
+			vs_masks.insert(vs_opt);
-                results.push_back({ vs_opt, fs_opt });
+		});
-            }
-        }
 
-        return results;
+		// Merge all FS variants
-    }
+		fs_masks.merge(fs_alpha_test_masks);
+
+		// Prepare outputs
+		std::vector<interpreter_variant_t> results;
+		for (const auto& vs_opt : vs_masks)
+		{
+			for (const auto& fs_opt : fs_masks)
+			{
+				results.push_back({ vs_opt, fs_opt });
+			}
+		}
+
+		return results;
+	}
 }

rpcs3/Emu/RSX/Program/ShaderInterpreter.h

@@ -6,30 +6,35 @@ namespace program_common
 {
 	namespace interpreter
 	{
-		enum compiler_option
+		enum compiler_option : u32
 		{
+			// FS Mix-N-Match
 			COMPILER_OPT_ENABLE_TEXTURES       = (1 << 0),
 			COMPILER_OPT_ENABLE_DEPTH_EXPORT   = (1 << 1),
 			COMPILER_OPT_ENABLE_F32_EXPORT     = (1 << 2),
-			COMPILER_OPT_ENABLE_ALPHA_TEST_GE  = (1 << 3),
+			COMPILER_OPT_ENABLE_PACKING        = (1 << 3),
-			COMPILER_OPT_ENABLE_ALPHA_TEST_G   = (1 << 4),
+			COMPILER_OPT_ENABLE_KIL            = (1 << 4),
-			COMPILER_OPT_ENABLE_ALPHA_TEST_LE  = (1 << 5),
+			COMPILER_OPT_ENABLE_STIPPLING      = (1 << 5),
-			COMPILER_OPT_ENABLE_ALPHA_TEST_L   = (1 << 6),
+			COMPILER_OPT_ENABLE_FLOW_CTRL      = (1 << 6),
-			COMPILER_OPT_ENABLE_ALPHA_TEST_EQ  = (1 << 7),
+
-			COMPILER_OPT_ENABLE_ALPHA_TEST_NE  = (1 << 8),
+			// VS Mix-N-Match
-			COMPILER_OPT_ENABLE_FLOW_CTRL      = (1 << 9),
+			COMPILER_OPT_ENABLE_INSTANCING     = (1 << 7),
-			COMPILER_OPT_ENABLE_PACKING        = (1 << 10),
+			COMPILER_OPT_ENABLE_VTX_TEXTURES   = (1 << 8),
-			COMPILER_OPT_ENABLE_KIL            = (1 << 11),
+
-			COMPILER_OPT_ENABLE_STIPPLING      = (1 << 12),
+			// Exclusive bits. Only one can be set at a time
-			COMPILER_OPT_ENABLE_INSTANCING     = (1 << 13),
+			COMPILER_OPT_ENABLE_ALPHA_TEST_GE  = (1 << 9),
-			COMPILER_OPT_ENABLE_VTX_TEXTURES   = (1 << 14),
+			COMPILER_OPT_ENABLE_ALPHA_TEST_G   = (1 << 10),
+			COMPILER_OPT_ENABLE_ALPHA_TEST_LE  = (1 << 11),
+			COMPILER_OPT_ENABLE_ALPHA_TEST_L   = (1 << 12),
+			COMPILER_OPT_ENABLE_ALPHA_TEST_EQ  = (1 << 13),
+			COMPILER_OPT_ENABLE_ALPHA_TEST_NE  = (1 << 14),
 
 			// Meta
-			COMPILER_OPT_MAX                   = COMPILER_OPT_ENABLE_VTX_TEXTURES,
+			COMPILER_OPT_MAX                   = COMPILER_OPT_ENABLE_ALPHA_TEST_NE,
-			COMPILER_OPT_ALPHA_TEST_MASK       = (0b111111 << COMPILER_OPT_ENABLE_ALPHA_TEST_GE),
+			COMPILER_OPT_ALPHA_TEST_MASK       = (0b111111 << 9),
 
 			// Bounds
-			COMPILER_OPT_FS_MAX                = COMPILER_OPT_ENABLE_STIPPLING,
+			COMPILER_OPT_FS_MAX                = COMPILER_OPT_ENABLE_FLOW_CTRL,
 			COMPILER_OPT_FS_MIN                = COMPILER_OPT_ENABLE_TEXTURES,
 			COMPILER_OPT_VS_MAX                = COMPILER_OPT_ENABLE_VTX_TEXTURES,
 			COMPILER_OPT_VS_MIN                = COMPILER_OPT_ENABLE_INSTANCING,

rpcs3/emucore.vcxproj

@@ -171,6 +171,7 @@
     <ClCompile Include="Emu\RSX\Program\Assembler\Passes\FP\RegisterDependencyPass.cpp" />
     <ClCompile Include="Emu\RSX\Program\ProgramStateCache.cpp" />
     <ClCompile Include="Emu\RSX\Program\program_util.cpp" />
+    <ClCompile Include="Emu\RSX\Program\ShaderInterpreter.cpp" />
     <ClCompile Include="Emu\RSX\Program\SPIRVCommon.cpp" />
     <ClCompile Include="Emu\RSX\RSXDisAsm.cpp" />
     <ClCompile Include="Emu\RSX\RSXZCULL.cpp" />

rpcs3/emucore.vcxproj.filters

@@ -1399,6 +1399,9 @@
     <ClCompile Include="Emu\RSX\Program\Assembler\FPASM.cpp">
       <Filter>Emu\GPU\RSX\Program\Assembler</Filter>
     </ClCompile>
+    <ClCompile Include="Emu\RSX\Program\ShaderInterpreter.cpp">
+      <Filter>Emu\GPU\RSX\Program</Filter>
+    </ClCompile>
     <ClCompile Include="Emu\Io\ps_move_data.cpp">
       <Filter>Emu\Io</Filter>
     </ClCompile>