Eliminate VarType for ComponentFormat

5 files changed, 136 insertions, 104 deletions

diff --git a/Source/Core/VideoBackends/D3D/D3DNativeVertexFormat.cpp b/Source/Core/VideoBackends/D3D/D3DNativeVertexFormat.cpp
index 80a59b57b3..8f7d9cad12 100644
--- a/Source/Core/VideoBackends/D3D/D3DNativeVertexFormat.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DNativeVertexFormat.cpp
@@ -3,6 +3,8 @@
 
 #include <array>
 
+#include "Common/EnumMap.h"
+
 #include "VideoBackends/D3D/D3DBase.h"
 #include "VideoBackends/D3D/D3DRender.h"
 #include "VideoBackends/D3D/D3DState.h"
@@ -20,55 +22,75 @@ Renderer::CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_decl)
   return std::make_unique<D3DVertexFormat>(vtx_decl);
 }
 
-static const DXGI_FORMAT d3d_format_lookup[5 * 4 * 2] = {
-    // float formats
-    DXGI_FORMAT_R8_UNORM,
-    DXGI_FORMAT_R8_SNORM,
-    DXGI_FORMAT_R16_UNORM,
-    DXGI_FORMAT_R16_SNORM,
-    DXGI_FORMAT_R32_FLOAT,
-    DXGI_FORMAT_R8G8_UNORM,
-    DXGI_FORMAT_R8G8_SNORM,
-    DXGI_FORMAT_R16G16_UNORM,
-    DXGI_FORMAT_R16G16_SNORM,
-    DXGI_FORMAT_R32G32_FLOAT,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_R32G32B32_FLOAT,
-    DXGI_FORMAT_R8G8B8A8_UNORM,
-    DXGI_FORMAT_R8G8B8A8_SNORM,
-    DXGI_FORMAT_R16G16B16A16_UNORM,
-    DXGI_FORMAT_R16G16B16A16_SNORM,
-    DXGI_FORMAT_R32G32B32A32_FLOAT,
-
-    // integer formats
-    DXGI_FORMAT_R8_UINT,
-    DXGI_FORMAT_R8_SINT,
-    DXGI_FORMAT_R16_UINT,
-    DXGI_FORMAT_R16_SINT,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_R8G8_UINT,
-    DXGI_FORMAT_R8G8_SINT,
-    DXGI_FORMAT_R16G16_UINT,
-    DXGI_FORMAT_R16G16_SINT,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_R8G8B8A8_UINT,
-    DXGI_FORMAT_R8G8B8A8_SINT,
-    DXGI_FORMAT_R16G16B16A16_UINT,
-    DXGI_FORMAT_R16G16B16A16_SINT,
-    DXGI_FORMAT_UNKNOWN,
-};
-
-DXGI_FORMAT VarToD3D(VarType t, int size, bool integer)
+DXGI_FORMAT VarToD3D(ComponentFormat t, int size, bool integer)
 {
-  DXGI_FORMAT retval = d3d_format_lookup[(int)t + 5 * (size - 1) + 5 * 4 * (int)integer];
+  using FormatMap = Common::EnumMap<DXGI_FORMAT, ComponentFormat::Float>;
+  static constexpr auto f = [](FormatMap a) { return a; };  // Deduction helper
+
+  static constexpr std::array<FormatMap, 4> d3d_float_format_lookup = {
+      f({
+          DXGI_FORMAT_R8_UNORM,
+          DXGI_FORMAT_R8_SNORM,
+          DXGI_FORMAT_R16_UNORM,
+          DXGI_FORMAT_R16_SNORM,
+          DXGI_FORMAT_R32_FLOAT,
+      }),
+      f({
+          DXGI_FORMAT_R8G8_UNORM,
+          DXGI_FORMAT_R8G8_SNORM,
+          DXGI_FORMAT_R16G16_UNORM,
+          DXGI_FORMAT_R16G16_SNORM,
+          DXGI_FORMAT_R32G32_FLOAT,
+      }),
+      f({
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_R32G32B32_FLOAT,
+      }),
+      f({
+          DXGI_FORMAT_R8G8B8A8_UNORM,
+          DXGI_FORMAT_R8G8B8A8_SNORM,
+          DXGI_FORMAT_R16G16B16A16_UNORM,
+          DXGI_FORMAT_R16G16B16A16_SNORM,
+          DXGI_FORMAT_R32G32B32A32_FLOAT,
+      }),
+  };
+
+  static constexpr std::array<FormatMap, 4> d3d_integer_format_lookup = {
+      f({
+          DXGI_FORMAT_R8_UINT,
+          DXGI_FORMAT_R8_SINT,
+          DXGI_FORMAT_R16_UINT,
+          DXGI_FORMAT_R16_SINT,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+      f({
+          DXGI_FORMAT_R8G8_UINT,
+          DXGI_FORMAT_R8G8_SINT,
+          DXGI_FORMAT_R16G16_UINT,
+          DXGI_FORMAT_R16G16_SINT,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+      f({
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+      f({
+          DXGI_FORMAT_R8G8B8A8_UINT,
+          DXGI_FORMAT_R8G8B8A8_SINT,
+          DXGI_FORMAT_R16G16B16A16_UINT,
+          DXGI_FORMAT_R16G16B16A16_SINT,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+  };
+
+  DXGI_FORMAT retval =
+      integer ? d3d_integer_format_lookup[size - 1][t] : d3d_float_format_lookup[size - 1][t];
   if (retval == DXGI_FORMAT_UNKNOWN)
   {
     PanicAlertFmt("VarToD3D: Invalid type/size combo {}, {}, {}", t, size, integer);
diff --git a/Source/Core/VideoBackends/D3D12/DX12VertexFormat.cpp b/Source/Core/VideoBackends/D3D12/DX12VertexFormat.cpp
index d95c8b9f7f..bd818d1a66 100644
--- a/Source/Core/VideoBackends/D3D12/DX12VertexFormat.cpp
+++ b/Source/Core/VideoBackends/D3D12/DX12VertexFormat.cpp
@@ -4,39 +4,43 @@
 #include "VideoBackends/D3D12/DX12VertexFormat.h"
 
 #include "Common/Assert.h"
+#include "Common/EnumMap.h"
 
 #include "VideoCommon/VertexLoaderManager.h"
 #include "VideoCommon/VertexShaderGen.h"
 
 namespace DX12
 {
-static DXGI_FORMAT VarToDXGIFormat(VarType t, u32 components, bool integer)
+static DXGI_FORMAT VarToDXGIFormat(ComponentFormat t, u32 components, bool integer)
 {
+  using ComponentArray = std::array<DXGI_FORMAT, 4>;
+  static constexpr auto f = [](ComponentArray a) { return a; };  // Deduction helper
+
   // NOTE: 3-component formats are not valid.
-  static const DXGI_FORMAT float_type_lookup[][4] = {
-      {DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM,
-       DXGI_FORMAT_R8G8B8A8_UNORM},  // VAR_UNSIGNED_BYTE
-      {DXGI_FORMAT_R8_SNORM, DXGI_FORMAT_R8G8_SNORM, DXGI_FORMAT_R8G8B8A8_SNORM,
-       DXGI_FORMAT_R8G8B8A8_SNORM},  // VAR_BYTE
-      {DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM,
-       DXGI_FORMAT_R16G16B16A16_UNORM},  // VAR_UNSIGNED_SHORT
-      {DXGI_FORMAT_R16_SNORM, DXGI_FORMAT_R16G16_SNORM, DXGI_FORMAT_R16G16B16A16_SNORM,
-       DXGI_FORMAT_R16G16B16A16_SNORM},  // VAR_SHORT
-      {DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
-       DXGI_FORMAT_R32G32B32A32_FLOAT}  // VAR_FLOAT
+  static constexpr Common::EnumMap<ComponentArray, ComponentFormat::Float> float_type_lookup = {
+      f({DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM,
+         DXGI_FORMAT_R8G8B8A8_UNORM}),  // UByte
+      f({DXGI_FORMAT_R8_SNORM, DXGI_FORMAT_R8G8_SNORM, DXGI_FORMAT_R8G8B8A8_SNORM,
+         DXGI_FORMAT_R8G8B8A8_SNORM}),  // Byte
+      f({DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM,
+         DXGI_FORMAT_R16G16B16A16_UNORM}),  // UShort
+      f({DXGI_FORMAT_R16_SNORM, DXGI_FORMAT_R16G16_SNORM, DXGI_FORMAT_R16G16B16A16_SNORM,
+         DXGI_FORMAT_R16G16B16A16_SNORM}),  // Short
+      f({DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
+         DXGI_FORMAT_R32G32B32A32_FLOAT}),  // Float
   };
 
-  static const DXGI_FORMAT integer_type_lookup[][4] = {
-      {DXGI_FORMAT_R8_UINT, DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_R8G8B8A8_UINT,
-       DXGI_FORMAT_R8G8B8A8_UINT},  // VAR_UNSIGNED_BYTE
-      {DXGI_FORMAT_R8_SINT, DXGI_FORMAT_R8G8_SINT, DXGI_FORMAT_R8G8B8A8_SINT,
-       DXGI_FORMAT_R8G8B8A8_SINT},  // VAR_BYTE
-      {DXGI_FORMAT_R16_UINT, DXGI_FORMAT_R16G16_UINT, DXGI_FORMAT_R16G16B16A16_UINT,
-       DXGI_FORMAT_R16G16B16A16_UINT},  // VAR_UNSIGNED_SHORT
-      {DXGI_FORMAT_R16_SINT, DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_R16G16B16A16_SINT,
-       DXGI_FORMAT_R16G16B16A16_SINT},  // VAR_SHORT
-      {DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
-       DXGI_FORMAT_R32G32B32A32_FLOAT}  // VAR_FLOAT
+  static constexpr Common::EnumMap<ComponentArray, ComponentFormat::Float> integer_type_lookup = {
+      f({DXGI_FORMAT_R8_UINT, DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_R8G8B8A8_UINT,
+         DXGI_FORMAT_R8G8B8A8_UINT}),  // UByte
+      f({DXGI_FORMAT_R8_SINT, DXGI_FORMAT_R8G8_SINT, DXGI_FORMAT_R8G8B8A8_SINT,
+         DXGI_FORMAT_R8G8B8A8_SINT}),  // Byte
+      f({DXGI_FORMAT_R16_UINT, DXGI_FORMAT_R16G16_UINT, DXGI_FORMAT_R16G16B16A16_UINT,
+         DXGI_FORMAT_R16G16B16A16_UINT}),  // UShort
+      f({DXGI_FORMAT_R16_SINT, DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_R16G16B16A16_SINT,
+         DXGI_FORMAT_R16G16B16A16_SINT}),  // Short
+      f({DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
+         DXGI_FORMAT_R32G32B32A32_FLOAT}),  // Float
   };
 
   ASSERT(components > 0 && components <= 4);
diff --git a/Source/Core/VideoBackends/OGL/OGLNativeVertexFormat.cpp b/Source/Core/VideoBackends/OGL/OGLNativeVertexFormat.cpp
index 9a6e568c8d..d21a40ebc1 100644
--- a/Source/Core/VideoBackends/OGL/OGLNativeVertexFormat.cpp
+++ b/Source/Core/VideoBackends/OGL/OGLNativeVertexFormat.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "Common/CommonTypes.h"
+#include "Common/EnumMap.h"
 #include "Common/GL/GLUtil.h"
 #include "Common/MsgHandler.h"
 
@@ -23,10 +24,11 @@ Renderer::CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_decl)
   return std::make_unique<GLVertexFormat>(vtx_decl);
 }
 
-static inline GLuint VarToGL(VarType t)
+static inline GLuint VarToGL(ComponentFormat t)
 {
-  static const GLuint lookup[5] = {GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT,
-                                   GL_FLOAT};
+  static constexpr Common::EnumMap<GLuint, ComponentFormat::Float> lookup = {
+      GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_FLOAT,
+  };
   return lookup[t];
 }
 
diff --git a/Source/Core/VideoBackends/Software/SWVertexLoader.cpp b/Source/Core/VideoBackends/Software/SWVertexLoader.cpp
index a7d0506a1f..af99e5ba85 100644
--- a/Source/Core/VideoBackends/Software/SWVertexLoader.cpp
+++ b/Source/Core/VideoBackends/Software/SWVertexLoader.cpp
@@ -145,7 +145,7 @@ static void ReadVertexAttribute(T* dst, DataReader src, const AttributeFormat& f
   if (format.enable)
   {
     src.Skip(format.offset);
-    src.Skip(base_component * (1 << (format.type >> 1)));
+    src.Skip(base_component * GetElementSize(format.type));
 
     int i;
     for (i = 0; i < std::min(format.components - base_component, components); i++)
@@ -153,24 +153,24 @@ static void ReadVertexAttribute(T* dst, DataReader src, const AttributeFormat& f
       int i_dst = reverse ? components - i - 1 : i;
       switch (format.type)
       {
-      case VAR_UNSIGNED_BYTE:
+      case ComponentFormat::UByte:
         dst[i_dst] = ReadNormalized<T, u8>(src.Read<u8, swap>());
         break;
-      case VAR_BYTE:
+      case ComponentFormat::Byte:
         dst[i_dst] = ReadNormalized<T, s8>(src.Read<s8, swap>());
         break;
-      case VAR_UNSIGNED_SHORT:
+      case ComponentFormat::UShort:
         dst[i_dst] = ReadNormalized<T, u16>(src.Read<u16, swap>());
         break;
-      case VAR_SHORT:
+      case ComponentFormat::Short:
         dst[i_dst] = ReadNormalized<T, s16>(src.Read<s16, swap>());
         break;
-      case VAR_FLOAT:
+      case ComponentFormat::Float:
         dst[i_dst] = ReadNormalized<T, float>(src.Read<float, swap>());
         break;
       }
 
-      ASSERT_MSG(VIDEO, !format.integer || format.type != VAR_FLOAT,
+      ASSERT_MSG(VIDEO, !format.integer || format.type != ComponentFormat::Float,
                  "only non-float values are allowed to be streamed as integer");
     }
     for (; i < components; i++)
diff --git a/Source/Core/VideoBackends/Vulkan/VKVertexFormat.cpp b/Source/Core/VideoBackends/Vulkan/VKVertexFormat.cpp
index e06beafbb8..5f53547066 100644
--- a/Source/Core/VideoBackends/Vulkan/VKVertexFormat.cpp
+++ b/Source/Core/VideoBackends/Vulkan/VKVertexFormat.cpp
@@ -4,6 +4,7 @@
 #include "VideoBackends/Vulkan/VKVertexFormat.h"
 
 #include "Common/Assert.h"
+#include "Common/EnumMap.h"
 
 #include "VideoBackends/Vulkan/CommandBufferManager.h"
 #include "VideoBackends/Vulkan/ObjectCache.h"
@@ -13,32 +14,35 @@
 
 namespace Vulkan
 {
-static VkFormat VarToVkFormat(VarType t, uint32_t components, bool integer)
+static VkFormat VarToVkFormat(ComponentFormat t, uint32_t components, bool integer)
 {
-  static const VkFormat float_type_lookup[][4] = {
-      {VK_FORMAT_R8_UNORM, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8B8_UNORM,
-       VK_FORMAT_R8G8B8A8_UNORM},  // VAR_UNSIGNED_BYTE
-      {VK_FORMAT_R8_SNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8B8_SNORM,
-       VK_FORMAT_R8G8B8A8_SNORM},  // VAR_BYTE
-      {VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16B16_UNORM,
-       VK_FORMAT_R16G16B16A16_UNORM},  // VAR_UNSIGNED_SHORT
-      {VK_FORMAT_R16_SNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16B16_SNORM,
-       VK_FORMAT_R16G16B16A16_SNORM},  // VAR_SHORT
-      {VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_SFLOAT,
-       VK_FORMAT_R32G32B32A32_SFLOAT}  // VAR_FLOAT
+  using ComponentArray = std::array<VkFormat, 4>;
+  static constexpr auto f = [](ComponentArray a) { return a; };  // Deduction helper
+
+  static constexpr Common::EnumMap<ComponentArray, ComponentFormat::Float> float_type_lookup = {
+      f({VK_FORMAT_R8_UNORM, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8B8_UNORM,
+         VK_FORMAT_R8G8B8A8_UNORM}),  // UByte
+      f({VK_FORMAT_R8_SNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8B8_SNORM,
+         VK_FORMAT_R8G8B8A8_SNORM}),  // Byte
+      f({VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16B16_UNORM,
+         VK_FORMAT_R16G16B16A16_UNORM}),  // UShort
+      f({VK_FORMAT_R16_SNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16B16_SNORM,
+         VK_FORMAT_R16G16B16A16_SNORM}),  // Short
+      f({VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_SFLOAT,
+         VK_FORMAT_R32G32B32A32_SFLOAT}),  // Float
   };
 
-  static const VkFormat integer_type_lookup[][4] = {
-      {VK_FORMAT_R8_UINT, VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8B8_UINT,
-       VK_FORMAT_R8G8B8A8_UINT},  // VAR_UNSIGNED_BYTE
-      {VK_FORMAT_R8_SINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8B8_SINT,
-       VK_FORMAT_R8G8B8A8_SINT},  // VAR_BYTE
-      {VK_FORMAT_R16_UINT, VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16B16_UINT,
-       VK_FORMAT_R16G16B16A16_UINT},  // VAR_UNSIGNED_SHORT
-      {VK_FORMAT_R16_SINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16B16_SINT,
-       VK_FORMAT_R16G16B16A16_SINT},  // VAR_SHORT
-      {VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_SFLOAT,
-       VK_FORMAT_R32G32B32A32_SFLOAT}  // VAR_FLOAT
+  static constexpr Common::EnumMap<ComponentArray, ComponentFormat::Float> integer_type_lookup = {
+      f({VK_FORMAT_R8_UINT, VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8B8_UINT,
+         VK_FORMAT_R8G8B8A8_UINT}),  // UByte
+      f({VK_FORMAT_R8_SINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8B8_SINT,
+         VK_FORMAT_R8G8B8A8_SINT}),  // Byte
+      f({VK_FORMAT_R16_UINT, VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16B16_UINT,
+         VK_FORMAT_R16G16B16A16_UINT}),  // UShort
+      f({VK_FORMAT_R16_SINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16B16_SINT,
+         VK_FORMAT_R16G16B16A16_SINT}),  // Short
+      f({VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_SFLOAT,
+         VK_FORMAT_R32G32B32A32_SFLOAT}),  // Float
   };
 
   ASSERT(components > 0 && components <= 4);