Merge pull request #9497 from Pokechu22/better-fifo-analyzer

Graphics refactoring + add names and descriptions in FIFO analyzer

1 files changed, 116 insertions, 107 deletions

diff --git a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp
index 666476dfce..bb09b1608e 100644
--- a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp
+++ b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp
@@ -28,7 +28,7 @@ TEST(VertexLoaderUID, UniqueEnough)
   memset(&vat, 0, sizeof(vat));
   uids.insert(VertexLoaderUID(vtx_desc, vat));
 
-  vtx_desc.Hex = 0xFEDCBA9876543210ull;
+  vtx_desc.SetLegacyHex(0xFEDCBA9876543210ull);
   EXPECT_EQ(uids.end(), uids.find(VertexLoaderUID(vtx_desc, vat)));
   uids.insert(VertexLoaderUID(vtx_desc, vat));
 
@@ -106,29 +106,37 @@ protected:
   std::unique_ptr<VertexLoaderBase> m_loader;
 };
 
-class VertexLoaderParamTest : public VertexLoaderTest,
-                              public ::testing::WithParamInterface<std::tuple<int, int, int, int>>
+class VertexLoaderParamTest
+    : public VertexLoaderTest,
+      public ::testing::WithParamInterface<
+          std::tuple<VertexComponentFormat, ComponentFormat, CoordComponentCount, int>>
 {
 };
-INSTANTIATE_TEST_CASE_P(AllCombinations, VertexLoaderParamTest,
-                        ::testing::Combine(::testing::Values(DIRECT, INDEX8, INDEX16),
-                                           ::testing::Values(FORMAT_UBYTE, FORMAT_BYTE,
-                                                             FORMAT_USHORT, FORMAT_SHORT,
-                                                             FORMAT_FLOAT),
-                                           ::testing::Values(0, 1),     // elements
-                                           ::testing::Values(0, 1, 31)  // frac
-                                           ));
+INSTANTIATE_TEST_CASE_P(
+    AllCombinations, VertexLoaderParamTest,
+    ::testing::Combine(
+        ::testing::Values(VertexComponentFormat::Direct, VertexComponentFormat::Index8,
+                          VertexComponentFormat::Index16),
+        ::testing::Values(ComponentFormat::UByte, ComponentFormat::Byte, ComponentFormat::UShort,
+                          ComponentFormat::Short, ComponentFormat::Float),
+        ::testing::Values(CoordComponentCount::XY, CoordComponentCount::XYZ),
+        ::testing::Values(0, 1, 31)  // frac
+        ));
 
 TEST_P(VertexLoaderParamTest, PositionAll)
 {
-  int addr, format, elements, frac;
+  VertexComponentFormat addr;
+  ComponentFormat format;
+  CoordComponentCount elements;
+  int frac;
   std::tie(addr, format, elements, frac) = GetParam();
-  this->m_vtx_desc.Position = addr;
+  this->m_vtx_desc.low.Position = addr;
   this->m_vtx_attr.g0.PosFormat = format;
   this->m_vtx_attr.g0.PosElements = elements;
   this->m_vtx_attr.g0.PosFrac = frac;
   this->m_vtx_attr.g0.ByteDequant = true;
-  elements += 2;
+  const u32 elem_size = GetElementSize(format);
+  const u32 elem_count = elements == CoordComponentCount::XY ? 2 : 3;
 
   std::vector<float> values = {
       std::numeric_limits<float>::lowest(),
@@ -153,38 +161,37 @@ TEST_P(VertexLoaderParamTest, PositionAll)
   ASSERT_EQ(0u, values.size() % 2);
   ASSERT_EQ(0u, values.size() % 3);
 
-  int count = (int)values.size() / elements;
-  u32 elem_size = 1 << (format / 2);
-  size_t input_size = elements * elem_size;
-  if (addr & MASK_INDEXED)
+  int count = (int)values.size() / elem_count;
+  size_t input_size = elem_count * elem_size;
+  if (IsIndexed(addr))
   {
-    input_size = addr - 1;
+    input_size = addr == VertexComponentFormat::Index8 ? 1 : 2;
     for (int i = 0; i < count; i++)
-      if (addr == INDEX8)
+      if (addr == VertexComponentFormat::Index8)
         Input<u8>(i);
       else
         Input<u16>(i);
     VertexLoaderManager::cached_arraybases[ARRAY_POSITION] = m_src.GetPointer();
-    g_main_cp_state.array_strides[ARRAY_POSITION] = elements * elem_size;
+    g_main_cp_state.array_strides[ARRAY_POSITION] = elem_count * elem_size;
   }
-  CreateAndCheckSizes(input_size, elements * sizeof(float));
+  CreateAndCheckSizes(input_size, elem_count * sizeof(float));
   for (float value : values)
   {
     switch (format)
     {
-    case FORMAT_UBYTE:
+    case ComponentFormat::UByte:
       Input((u8)value);
       break;
-    case FORMAT_BYTE:
+    case ComponentFormat::Byte:
       Input((s8)value);
       break;
-    case FORMAT_USHORT:
+    case ComponentFormat::UShort:
       Input((u16)value);
       break;
-    case FORMAT_SHORT:
+    case ComponentFormat::Short:
       Input((s16)value);
       break;
-    case FORMAT_FLOAT:
+    case ComponentFormat::Float:
       Input(value);
       break;
     }
@@ -192,29 +199,29 @@ TEST_P(VertexLoaderParamTest, PositionAll)
 
   RunVertices(count);
 
-  float scale = 1.f / (1u << (format == FORMAT_FLOAT ? 0 : frac));
+  float scale = 1.f / (1u << (format == ComponentFormat::Float ? 0 : frac));
   for (auto iter = values.begin(); iter != values.end();)
   {
     float f, g;
     switch (format)
     {
-    case FORMAT_UBYTE:
+    case ComponentFormat::UByte:
       f = (u8)*iter++;
       g = (u8)*iter++;
       break;
-    case FORMAT_BYTE:
+    case ComponentFormat::Byte:
       f = (s8)*iter++;
       g = (s8)*iter++;
       break;
-    case FORMAT_USHORT:
+    case ComponentFormat::UShort:
       f = (u16)*iter++;
       g = (u16)*iter++;
       break;
-    case FORMAT_SHORT:
+    case ComponentFormat::Short:
       f = (s16)*iter++;
       g = (s16)*iter++;
       break;
-    case FORMAT_FLOAT:
+    case ComponentFormat::Float:
       f = *iter++;
       g = *iter++;
       break;
@@ -228,8 +235,8 @@ TEST_P(VertexLoaderParamTest, PositionAll)
 
 TEST_F(VertexLoaderTest, PositionIndex16FloatXY)
 {
-  m_vtx_desc.Position = INDEX16;
-  m_vtx_attr.g0.PosFormat = FORMAT_FLOAT;
+  m_vtx_desc.low.Position = VertexComponentFormat::Index16;
+  m_vtx_attr.g0.PosFormat = ComponentFormat::Float;
   CreateAndCheckSizes(sizeof(u16), 2 * sizeof(float));
   Input<u16>(1);
   Input<u16>(0);
@@ -246,47 +253,49 @@ TEST_F(VertexLoaderTest, PositionIndex16FloatXY)
 }
 
 class VertexLoaderSpeedTest : public VertexLoaderTest,
-                              public ::testing::WithParamInterface<std::tuple<int, int>>
+                              public ::testing::WithParamInterface<std::tuple<ComponentFormat, int>>
 {
 };
-INSTANTIATE_TEST_CASE_P(FormatsAndElements, VertexLoaderSpeedTest,
-                        ::testing::Combine(::testing::Values(FORMAT_UBYTE, FORMAT_BYTE,
-                                                             FORMAT_USHORT, FORMAT_SHORT,
-                                                             FORMAT_FLOAT),
-                                           ::testing::Values(0, 1)  // elements
-                                           ));
+INSTANTIATE_TEST_CASE_P(
+    FormatsAndElements, VertexLoaderSpeedTest,
+    ::testing::Combine(::testing::Values(ComponentFormat::UByte, ComponentFormat::Byte,
+                                         ComponentFormat::UShort, ComponentFormat::Short,
+                                         ComponentFormat::Float),
+                       ::testing::Values(0, 1)));
 
 TEST_P(VertexLoaderSpeedTest, PositionDirectAll)
 {
-  int format, elements;
-  std::tie(format, elements) = GetParam();
-  const char* map[] = {"u8", "s8", "u16", "s16", "float"};
-  printf("format: %s, elements: %d\n", map[format], elements);
-  m_vtx_desc.Position = DIRECT;
+  ComponentFormat format;
+  int elements_i;
+  std::tie(format, elements_i) = GetParam();
+  CoordComponentCount elements = static_cast<CoordComponentCount>(elements_i);
+  fmt::print("format: {}, elements: {}\n", format, elements);
+  const u32 elem_count = elements == CoordComponentCount::XY ? 2 : 3;
+  m_vtx_desc.low.Position = VertexComponentFormat::Direct;
   m_vtx_attr.g0.PosFormat = format;
   m_vtx_attr.g0.PosElements = elements;
-  elements += 2;
-  size_t elem_size = static_cast<size_t>(1) << (format / 2);
-  CreateAndCheckSizes(elements * elem_size, elements * sizeof(float));
+  const size_t elem_size = GetElementSize(format);
+  CreateAndCheckSizes(elem_count * elem_size, elem_count * sizeof(float));
   for (int i = 0; i < 1000; ++i)
     RunVertices(100000);
 }
 
 TEST_P(VertexLoaderSpeedTest, TexCoordSingleElement)
 {
-  int format, elements;
-  std::tie(format, elements) = GetParam();
-  const char* map[] = {"u8", "s8", "u16", "s16", "float"};
-  printf("format: %s, elements: %d\n", map[format], elements);
-  m_vtx_desc.Position = DIRECT;
-  m_vtx_attr.g0.PosFormat = FORMAT_BYTE;
-  m_vtx_desc.Tex0Coord = DIRECT;
+  ComponentFormat format;
+  int elements_i;
+  std::tie(format, elements_i) = GetParam();
+  TexComponentCount elements = static_cast<TexComponentCount>(elements_i);
+  fmt::print("format: {}, elements: {}\n", format, elements);
+  const u32 elem_count = elements == TexComponentCount::S ? 1 : 2;
+  m_vtx_desc.low.Position = VertexComponentFormat::Direct;
+  m_vtx_attr.g0.PosFormat = ComponentFormat::Byte;
+  m_vtx_desc.high.Tex0Coord = VertexComponentFormat::Direct;
   m_vtx_attr.g0.Tex0CoordFormat = format;
   m_vtx_attr.g0.Tex0CoordElements = elements;
-  elements += 1;
-  size_t elem_size = static_cast<size_t>(1) << (format / 2);
-  CreateAndCheckSizes(2 * sizeof(s8) + elements * elem_size,
-                      2 * sizeof(float) + elements * sizeof(float));
+  const size_t elem_size = GetElementSize(format);
+  CreateAndCheckSizes(2 * sizeof(s8) + elem_count * elem_size,
+                      2 * sizeof(float) + elem_count * sizeof(float));
   for (int i = 0; i < 1000; ++i)
     RunVertices(100000);
 }
@@ -294,52 +303,52 @@ TEST_P(VertexLoaderSpeedTest, TexCoordSingleElement)
 TEST_F(VertexLoaderTest, LargeFloatVertexSpeed)
 {
   // Enables most attributes in floating point indexed mode to test speed.
-  m_vtx_desc.PosMatIdx = 1;
-  m_vtx_desc.Tex0MatIdx = 1;
-  m_vtx_desc.Tex1MatIdx = 1;
-  m_vtx_desc.Tex2MatIdx = 1;
-  m_vtx_desc.Tex3MatIdx = 1;
-  m_vtx_desc.Tex4MatIdx = 1;
-  m_vtx_desc.Tex5MatIdx = 1;
-  m_vtx_desc.Tex6MatIdx = 1;
-  m_vtx_desc.Tex7MatIdx = 1;
-  m_vtx_desc.Position = INDEX16;
-  m_vtx_desc.Normal = INDEX16;
-  m_vtx_desc.Color0 = INDEX16;
-  m_vtx_desc.Color1 = INDEX16;
-  m_vtx_desc.Tex0Coord = INDEX16;
-  m_vtx_desc.Tex1Coord = INDEX16;
-  m_vtx_desc.Tex2Coord = INDEX16;
-  m_vtx_desc.Tex3Coord = INDEX16;
-  m_vtx_desc.Tex4Coord = INDEX16;
-  m_vtx_desc.Tex5Coord = INDEX16;
-  m_vtx_desc.Tex6Coord = INDEX16;
-  m_vtx_desc.Tex7Coord = INDEX16;
-
-  m_vtx_attr.g0.PosElements = 1;  // XYZ
-  m_vtx_attr.g0.PosFormat = FORMAT_FLOAT;
-  m_vtx_attr.g0.NormalElements = 1;  // NBT
-  m_vtx_attr.g0.NormalFormat = FORMAT_FLOAT;
-  m_vtx_attr.g0.Color0Elements = 1;  // Has Alpha
-  m_vtx_attr.g0.Color0Comp = FORMAT_32B_8888;
-  m_vtx_attr.g0.Color1Elements = 1;  // Has Alpha
-  m_vtx_attr.g0.Color1Comp = FORMAT_32B_8888;
-  m_vtx_attr.g0.Tex0CoordElements = 1;  // ST
-  m_vtx_attr.g0.Tex0CoordFormat = FORMAT_FLOAT;
-  m_vtx_attr.g1.Tex1CoordElements = 1;  // ST
-  m_vtx_attr.g1.Tex1CoordFormat = FORMAT_FLOAT;
-  m_vtx_attr.g1.Tex2CoordElements = 1;  // ST
-  m_vtx_attr.g1.Tex2CoordFormat = FORMAT_FLOAT;
-  m_vtx_attr.g1.Tex3CoordElements = 1;  // ST
-  m_vtx_attr.g1.Tex3CoordFormat = FORMAT_FLOAT;
-  m_vtx_attr.g1.Tex4CoordElements = 1;  // ST
-  m_vtx_attr.g1.Tex4CoordFormat = FORMAT_FLOAT;
-  m_vtx_attr.g2.Tex5CoordElements = 1;  // ST
-  m_vtx_attr.g2.Tex5CoordFormat = FORMAT_FLOAT;
-  m_vtx_attr.g2.Tex6CoordElements = 1;  // ST
-  m_vtx_attr.g2.Tex6CoordFormat = FORMAT_FLOAT;
-  m_vtx_attr.g2.Tex7CoordElements = 1;  // ST
-  m_vtx_attr.g2.Tex7CoordFormat = FORMAT_FLOAT;
+  m_vtx_desc.low.PosMatIdx = 1;
+  m_vtx_desc.low.Tex0MatIdx = 1;
+  m_vtx_desc.low.Tex1MatIdx = 1;
+  m_vtx_desc.low.Tex2MatIdx = 1;
+  m_vtx_desc.low.Tex3MatIdx = 1;
+  m_vtx_desc.low.Tex4MatIdx = 1;
+  m_vtx_desc.low.Tex5MatIdx = 1;
+  m_vtx_desc.low.Tex6MatIdx = 1;
+  m_vtx_desc.low.Tex7MatIdx = 1;
+  m_vtx_desc.low.Position = VertexComponentFormat::Index16;
+  m_vtx_desc.low.Normal = VertexComponentFormat::Index16;
+  m_vtx_desc.low.Color0 = VertexComponentFormat::Index16;
+  m_vtx_desc.low.Color1 = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex0Coord = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex1Coord = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex2Coord = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex3Coord = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex4Coord = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex5Coord = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex6Coord = VertexComponentFormat::Index16;
+  m_vtx_desc.high.Tex7Coord = VertexComponentFormat::Index16;
+
+  m_vtx_attr.g0.PosElements = CoordComponentCount::XYZ;
+  m_vtx_attr.g0.PosFormat = ComponentFormat::Float;
+  m_vtx_attr.g0.NormalElements = NormalComponentCount::NBT;
+  m_vtx_attr.g0.NormalFormat = ComponentFormat::Float;
+  m_vtx_attr.g0.Color0Elements = ColorComponentCount::RGBA;
+  m_vtx_attr.g0.Color0Comp = ColorFormat::RGBA8888;
+  m_vtx_attr.g0.Color1Elements = ColorComponentCount::RGBA;
+  m_vtx_attr.g0.Color1Comp = ColorFormat::RGBA8888;
+  m_vtx_attr.g0.Tex0CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g0.Tex0CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex1CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex1CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex2CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex2CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex3CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex3CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex4CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex4CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g2.Tex5CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g2.Tex5CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g2.Tex6CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g2.Tex6CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g2.Tex7CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g2.Tex7CoordFormat = ComponentFormat::Float;
 
   CreateAndCheckSizes(33, 156);