Merge pull request #8143 from lioncash/loader

VertexLoader_*: Minor cleanup

5 files changed, 142 insertions, 261 deletions

diff --git a/Source/Core/VideoCommon/VertexLoader_Color.cpp b/Source/Core/VideoCommon/VertexLoader_Color.cpp
index 7a87519bd3..6e8bbd4e44 100644
--- a/Source/Core/VideoCommon/VertexLoader_Color.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_Color.cpp
@@ -12,9 +12,11 @@
 #include "VideoCommon/VertexLoaderUtils.h"
 #include "VideoCommon/VertexLoader_Color.h"
 
-#define AMASK 0xFF000000
+namespace
+{
+constexpr u32 alpha_mask = 0xFF000000;
 
-static void SetCol(VertexLoader* loader, u32 val)
+void SetCol(VertexLoader* loader, u32 val)
 {
   DataWrite(val);
   loader->m_colIndex++;
@@ -22,7 +24,7 @@ static void SetCol(VertexLoader* loader, u32 val)
 
 // Color comes in format BARG in 16 bits
 // BARG -> AABBGGRR
-static void SetCol4444(VertexLoader* loader, u16 val_)
+void SetCol4444(VertexLoader* loader, u16 val_)
 {
   u32 col, val = val_;
   col = val & 0x00F0;           // col  = 000000R0;
@@ -35,7 +37,7 @@ static void SetCol4444(VertexLoader* loader, u16 val_)
 
 // Color comes in format RGBA
 // RRRRRRGG GGGGBBBB BBAAAAAA
-static void SetCol6666(VertexLoader* loader, u32 val)
+void SetCol6666(VertexLoader* loader, u32 val)
 {
   u32 col = (val >> 16) & 0x000000FC;
   col |= (val >> 2) & 0x0000FC00;
@@ -47,7 +49,7 @@ static void SetCol6666(VertexLoader* loader, u32 val)
 
 // Color comes in RGB
 // RRRRRGGG GGGBBBBB
-static void SetCol565(VertexLoader* loader, u16 val_)
+void SetCol565(VertexLoader* loader, u16 val_)
 {
   u32 col, val = val_;
   col = (val >> 8) & 0x0000F8;
@@ -55,61 +57,28 @@ static void SetCol565(VertexLoader* loader, u16 val_)
   col |= (val << 19) & 0xF80000;
   col |= (col >> 5) & 0x070007;
   col |= (col >> 6) & 0x000300;
-  SetCol(loader, col | AMASK);
+  SetCol(loader, col | alpha_mask);
 }
 
-static u32 Read32(const u8* addr)
+u32 Read32(const u8* addr)
 {
   u32 value;
   std::memcpy(&value, addr, sizeof(u32));
   return value;
 }
 
-static u32 Read24(const u8* addr)
-{
-  return Read32(addr) | AMASK;
-}
-
-void Color_ReadDirect_24b_888(VertexLoader* loader)
-{
-  SetCol(loader, Read24(DataGetPosition()));
-  DataSkip(3);
-}
-
-void Color_ReadDirect_32b_888x(VertexLoader* loader)
-{
-  SetCol(loader, Read24(DataGetPosition()));
-  DataSkip(4);
-}
-void Color_ReadDirect_16b_565(VertexLoader* loader)
-{
-  SetCol565(loader, DataRead<u16>());
-}
-void Color_ReadDirect_16b_4444(VertexLoader* loader)
-{
-  u16 value;
-  std::memcpy(&value, DataGetPosition(), sizeof(u16));
-
-  SetCol4444(loader, value);
-  DataSkip(2);
-}
-void Color_ReadDirect_24b_6666(VertexLoader* loader)
-{
-  SetCol6666(loader, Common::swap32(DataGetPosition() - 1));
-  DataSkip(3);
-}
-void Color_ReadDirect_32b_8888(VertexLoader* loader)
+u32 Read24(const u8* addr)
 {
-  SetCol(loader, DataReadU32Unswapped());
+  return Read32(addr) | alpha_mask;
 }
 
 template <typename I>
 void Color_ReadIndex_16b_565(VertexLoader* loader)
 {
-  auto const Index = DataRead<I>();
+  const auto index = DataRead<I>();
   const u8* const address =
       VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
-      (Index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
+      (index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
 
   u16 value;
   std::memcpy(&value, address, sizeof(u16));
@@ -120,28 +89,28 @@ void Color_ReadIndex_16b_565(VertexLoader* loader)
 template <typename I>
 void Color_ReadIndex_24b_888(VertexLoader* loader)
 {
-  auto const Index = DataRead<I>();
-  const u8* iAddress = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
-                       (Index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
-  SetCol(loader, Read24(iAddress));
+  const auto index = DataRead<I>();
+  const u8* address = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
+                      (index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
+  SetCol(loader, Read24(address));
 }
 
 template <typename I>
 void Color_ReadIndex_32b_888x(VertexLoader* loader)
 {
-  auto const Index = DataRead<I>();
-  const u8* iAddress = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
-                       (Index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
-  SetCol(loader, Read24(iAddress));
+  const auto index = DataRead<I>();
+  const u8* address = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
+                      (index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
+  SetCol(loader, Read24(address));
 }
 
 template <typename I>
 void Color_ReadIndex_16b_4444(VertexLoader* loader)
 {
-  auto const Index = DataRead<I>();
+  auto const index = DataRead<I>();
   const u8* const address =
       VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
-      (Index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
+      (index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
 
   u16 value;
   std::memcpy(&value, address, sizeof(u16));
@@ -152,20 +121,54 @@ void Color_ReadIndex_16b_4444(VertexLoader* loader)
 template <typename I>
 void Color_ReadIndex_24b_6666(VertexLoader* loader)
 {
-  auto const Index = DataRead<I>();
-  const u8* pData = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
-                    (Index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]) - 1;
-  u32 val = Common::swap32(pData);
+  const auto index = DataRead<I>();
+  const u8* data = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
+                   (index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]) - 1;
+  const u32 val = Common::swap32(data);
   SetCol6666(loader, val);
 }
 
 template <typename I>
 void Color_ReadIndex_32b_8888(VertexLoader* loader)
 {
-  auto const Index = DataRead<I>();
-  const u8* iAddress = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
-                       (Index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
-  SetCol(loader, Read32(iAddress));
+  const auto index = DataRead<I>();
+  const u8* address = VertexLoaderManager::cached_arraybases[ARRAY_COLOR + loader->m_colIndex] +
+                      (index * g_main_cp_state.array_strides[ARRAY_COLOR + loader->m_colIndex]);
+  SetCol(loader, Read32(address));
+}
+}  // Anonymous namespace
+
+void Color_ReadDirect_24b_888(VertexLoader* loader)
+{
+  SetCol(loader, Read24(DataGetPosition()));
+  DataSkip(3);
+}
+
+void Color_ReadDirect_32b_888x(VertexLoader* loader)
+{
+  SetCol(loader, Read24(DataGetPosition()));
+  DataSkip(4);
+}
+void Color_ReadDirect_16b_565(VertexLoader* loader)
+{
+  SetCol565(loader, DataRead<u16>());
+}
+void Color_ReadDirect_16b_4444(VertexLoader* loader)
+{
+  u16 value;
+  std::memcpy(&value, DataGetPosition(), sizeof(u16));
+
+  SetCol4444(loader, value);
+  DataSkip(2);
+}
+void Color_ReadDirect_24b_6666(VertexLoader* loader)
+{
+  SetCol6666(loader, Common::swap32(DataGetPosition() - 1));
+  DataSkip(3);
+}
+void Color_ReadDirect_32b_8888(VertexLoader* loader)
+{
+  SetCol(loader, DataReadU32Unswapped());
 }
 
 void Color_ReadIndex8_16b_565(VertexLoader* loader)
diff --git a/Source/Core/VideoCommon/VertexLoader_Position.cpp b/Source/Core/VideoCommon/VertexLoader_Position.cpp
index a21061ac55..9808c76e65 100644
--- a/Source/Core/VideoCommon/VertexLoader_Position.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_Position.cpp
@@ -16,14 +16,16 @@
 #include "VideoCommon/VertexLoaderUtils.h"
 #include "VideoCommon/VideoCommon.h"
 
+namespace
+{
 template <typename T>
-float PosScale(T val, float scale)
+constexpr float PosScale(T val, float scale)
 {
   return val * scale;
 }
 
 template <>
-float PosScale(float val, float scale)
+constexpr float PosScale(float val, [[maybe_unused]] float scale)
 {
   return val;
 }
@@ -32,13 +34,13 @@ template <typename T, int N>
 void Pos_ReadDirect(VertexLoader* loader)
 {
   static_assert(N <= 3, "N > 3 is not sane!");
-  auto const scale = loader->m_posScale;
+  const auto scale = loader->m_posScale;
   DataReader dst(g_vertex_manager_write_ptr, nullptr);
   DataReader src(g_video_buffer_read_ptr, nullptr);
 
   for (int i = 0; i < N; ++i)
   {
-    float value = PosScale(src.Read<T>(), scale);
+    const float value = PosScale(src.Read<T>(), scale);
     if (loader->m_counter < 3)
       VertexLoaderManager::position_cache[loader->m_counter][i] = value;
     dst.Write(value);
@@ -55,17 +57,17 @@ void Pos_ReadIndex(VertexLoader* loader)
   static_assert(std::is_unsigned<I>::value, "Only unsigned I is sane!");
   static_assert(N <= 3, "N > 3 is not sane!");
 
-  auto const index = DataRead<I>();
+  const auto index = DataRead<I>();
   loader->m_vertexSkip = index == std::numeric_limits<I>::max();
-  auto const data =
+  const auto data =
       reinterpret_cast<const T*>(VertexLoaderManager::cached_arraybases[ARRAY_POSITION] +
                                  (index * g_main_cp_state.array_strides[ARRAY_POSITION]));
-  auto const scale = loader->m_posScale;
+  const auto scale = loader->m_posScale;
   DataReader dst(g_vertex_manager_write_ptr, nullptr);
 
   for (int i = 0; i < N; ++i)
   {
-    float value = PosScale(Common::FromBigEndian(data[i]), scale);
+    const float value = PosScale(Common::FromBigEndian(data[i]), scale);
     if (loader->m_counter < 3)
       VertexLoaderManager::position_cache[loader->m_counter][i] = value;
     dst.Write(value);
@@ -75,7 +77,7 @@ void Pos_ReadIndex(VertexLoader* loader)
   LOG_VTX();
 }
 
-static TPipelineFunction tableReadPosition[4][8][2] = {
+constexpr TPipelineFunction s_table_read_position[4][8][2] = {
     {
         {
             nullptr,
@@ -166,104 +168,44 @@ static TPipelineFunction tableReadPosition[4][8][2] = {
     },
 };
 
-static int tableReadPositionVertexSize[4][8][2] = {
+constexpr u32 s_table_read_position_vertex_size[4][8][2] = {
     {
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
+        {0, 0},
+        {0, 0},
+        {0, 0},
+        {0, 0},
+        {0, 0},
     },
     {
-        {
-            2,
-            3,
-        },
-        {
-            2,
-            3,
-        },
-        {
-            4,
-            6,
-        },
-        {
-            4,
-            6,
-        },
-        {
-            8,
-            12,
-        },
+        {2, 3},
+        {2, 3},
+        {4, 6},
+        {4, 6},
+        {8, 12},
     },
     {
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
+        {1, 1},
+        {1, 1},
+        {1, 1},
+        {1, 1},
+        {1, 1},
     },
     {
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
+        {2, 2},
+        {2, 2},
+        {2, 2},
+        {2, 2},
+        {2, 2},
     },
 };
+}  // Anonymous namespace
 
-unsigned int VertexLoader_Position::GetSize(u64 _type, unsigned int _format, unsigned int _elements)
+u32 VertexLoader_Position::GetSize(u64 type, u32 format, u32 elements)
 {
-  return tableReadPositionVertexSize[_type][_format][_elements];
+  return s_table_read_position_vertex_size[type][format][elements];
 }
 
-TPipelineFunction VertexLoader_Position::GetFunction(u64 _type, unsigned int _format,
-                                                     unsigned int _elements)
+TPipelineFunction VertexLoader_Position::GetFunction(u64 type, u32 format, u32 elements)
 {
-  return tableReadPosition[_type][_format][_elements];
+  return s_table_read_position[type][format][elements];
 }
diff --git a/Source/Core/VideoCommon/VertexLoader_Position.h b/Source/Core/VideoCommon/VertexLoader_Position.h
index 1a8a2855e3..a38d277278 100644
--- a/Source/Core/VideoCommon/VertexLoader_Position.h
+++ b/Source/Core/VideoCommon/VertexLoader_Position.h
@@ -10,9 +10,7 @@
 class VertexLoader_Position
 {
 public:
-  // GetSize
-  static unsigned int GetSize(u64 _type, unsigned int _format, unsigned int _elements);
+  static u32 GetSize(u64 type, u32 format, u32 elements);
 
-  // GetFunction
-  static TPipelineFunction GetFunction(u64 _type, unsigned int _format, unsigned int _elements);
+  static TPipelineFunction GetFunction(u64 type, u32 format, u32 elements);
 };
diff --git a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
index a64e1f1cde..3a31527b2c 100644
--- a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
@@ -14,6 +14,8 @@
 #include "VideoCommon/VertexLoaderManager.h"
 #include "VideoCommon/VertexLoaderUtils.h"
 
+namespace
+{
 template <int N>
 void LOG_TEX();
 
@@ -32,19 +34,19 @@ void LOG_TEX<2>()
   // ((float*)g_vertex_manager_write_ptr)[-1]);
 }
 
-static void TexCoord_Read_Dummy(VertexLoader* loader)
+void TexCoord_Read_Dummy(VertexLoader* loader)
 {
   loader->m_tcIndex++;
 }
 
 template <typename T>
-float TCScale(T val, float scale)
+constexpr float TCScale(T val, float scale)
 {
   return val * scale;
 }
 
 template <>
-float TCScale(float val, float scale)
+constexpr float TCScale(float val, [[maybe_unused]] float scale)
 {
   return val;
 }
@@ -52,7 +54,7 @@ float TCScale(float val, float scale)
 template <typename T, int N>
 void TexCoord_ReadDirect(VertexLoader* loader)
 {
-  auto const scale = loader->m_tcScale[loader->m_tcIndex];
+  const auto scale = loader->m_tcScale[loader->m_tcIndex];
   DataReader dst(g_vertex_manager_write_ptr, nullptr);
   DataReader src(g_video_buffer_read_ptr, nullptr);
 
@@ -71,11 +73,11 @@ void TexCoord_ReadIndex(VertexLoader* loader)
 {
   static_assert(std::is_unsigned<I>::value, "Only unsigned I is sane!");
 
-  auto const index = DataRead<I>();
-  auto const data = reinterpret_cast<const T*>(
+  const auto index = DataRead<I>();
+  const auto data = reinterpret_cast<const T*>(
       VertexLoaderManager::cached_arraybases[ARRAY_TEXCOORD0 + loader->m_tcIndex] +
       (index * g_main_cp_state.array_strides[ARRAY_TEXCOORD0 + loader->m_tcIndex]));
-  auto const scale = loader->m_tcScale[loader->m_tcIndex];
+  const auto scale = loader->m_tcScale[loader->m_tcIndex];
   DataReader dst(g_vertex_manager_write_ptr, nullptr);
 
   for (int i = 0; i != N; ++i)
@@ -86,7 +88,7 @@ void TexCoord_ReadIndex(VertexLoader* loader)
   ++loader->m_tcIndex;
 }
 
-static TPipelineFunction tableReadTexCoord[4][8][2] = {
+constexpr TPipelineFunction s_table_read_tex_coord[4][8][2] = {
     {
         {
             nullptr,
@@ -177,107 +179,46 @@ static TPipelineFunction tableReadTexCoord[4][8][2] = {
     },
 };
 
-static int tableReadTexCoordVertexSize[4][8][2] = {
+constexpr u32 s_table_read_tex_coord_vertex_size[4][8][2] = {
     {
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
-        {
-            0,
-            0,
-        },
+        {0, 0},
+        {0, 0},
+        {0, 0},
+        {0, 0},
+        {0, 0},
     },
     {
-        {
-            1,
-            2,
-        },
-        {
-            1,
-            2,
-        },
-        {
-            2,
-            4,
-        },
-        {
-            2,
-            4,
-        },
-        {
-            4,
-            8,
-        },
+        {1, 2},
+        {1, 2},
+        {2, 4},
+        {2, 4},
+        {4, 8},
     },
     {
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
-        {
-            1,
-            1,
-        },
+        {1, 1},
+        {1, 1},
+        {1, 1},
+        {1, 1},
+        {1, 1},
     },
     {
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
-        {
-            2,
-            2,
-        },
+        {2, 2},
+        {2, 2},
+        {2, 2},
+        {2, 2},
+        {2, 2},
     },
 };
+}  // Anonymous namespace
 
-unsigned int VertexLoader_TextCoord::GetSize(u64 _type, unsigned int _format,
-                                             unsigned int _elements)
+u32 VertexLoader_TextCoord::GetSize(u64 type, u32 format, u32 elements)
 {
-  return tableReadTexCoordVertexSize[_type][_format][_elements];
+  return s_table_read_tex_coord_vertex_size[type][format][elements];
 }
 
-TPipelineFunction VertexLoader_TextCoord::GetFunction(u64 _type, unsigned int _format,
-                                                      unsigned int _elements)
+TPipelineFunction VertexLoader_TextCoord::GetFunction(u64 type, u32 format, u32 elements)
 {
-  return tableReadTexCoord[_type][_format][_elements];
+  return s_table_read_tex_coord[type][format][elements];
 }
 
 TPipelineFunction VertexLoader_TextCoord::GetDummyFunction()
diff --git a/Source/Core/VideoCommon/VertexLoader_TextCoord.h b/Source/Core/VideoCommon/VertexLoader_TextCoord.h
index 1b135e46d3..48b9a8e136 100644
--- a/Source/Core/VideoCommon/VertexLoader_TextCoord.h
+++ b/Source/Core/VideoCommon/VertexLoader_TextCoord.h
@@ -10,13 +10,10 @@
 class VertexLoader_TextCoord
 {
 public:
-  // GetSize
-  static unsigned int GetSize(u64 _type, unsigned int _format, unsigned int _elements);
+  static u32 GetSize(u64 type, u32 format, u32 elements);
 
-  // GetFunction
-  static TPipelineFunction GetFunction(u64 _type, unsigned int _format, unsigned int _elements);
+  static TPipelineFunction GetFunction(u64 type, u32 format, u32 elements);
 
-  // GetDummyFunction
   // It is important to synchronize tcIndex.
   static TPipelineFunction GetDummyFunction();
 };