Eliminate TVtxAttr

Source/Core/VideoCommon/CPMemory.h

@@ -317,7 +317,7 @@ union UVAT_group0
   // 21:29
   BitField<21, 1, TexComponentCount> Tex0CoordElements;
   BitField<22, 3, ComponentFormat> Tex0CoordFormat;
-  BitField<25, 5, u32> Tex0Frac;
+  BitField<25, 5, u8, u32> Tex0Frac;
   // 30:31
   BitField<30, 1, bool, u32> ByteDequant;
   BitField<31, 1, bool, u32> NormalIndex3;
@@ -363,15 +363,15 @@ union UVAT_group1
   // 0:8
   BitField<0, 1, TexComponentCount> Tex1CoordElements;
   BitField<1, 3, ComponentFormat> Tex1CoordFormat;
-  BitField<4, 5, u32> Tex1Frac;
+  BitField<4, 5, u8, u32> Tex1Frac;
   // 9:17
   BitField<9, 1, TexComponentCount> Tex2CoordElements;
   BitField<10, 3, ComponentFormat> Tex2CoordFormat;
-  BitField<13, 5, u32> Tex2Frac;
+  BitField<13, 5, u8, u32> Tex2Frac;
   // 18:26
   BitField<18, 1, TexComponentCount> Tex3CoordElements;
   BitField<19, 3, ComponentFormat> Tex3CoordFormat;
-  BitField<22, 5, u32> Tex3Frac;
+  BitField<22, 5, u8, u32> Tex3Frac;
   // 27:30
   BitField<27, 1, TexComponentCount> Tex4CoordElements;
   BitField<28, 3, ComponentFormat> Tex4CoordFormat;
@@ -410,19 +410,19 @@ union UVAT_group2
 {
   u32 Hex;
   // 0:4
-  BitField<0, 5, u32> Tex4Frac;
+  BitField<0, 5, u8, u32> Tex4Frac;
   // 5:13
   BitField<5, 1, TexComponentCount> Tex5CoordElements;
   BitField<6, 3, ComponentFormat> Tex5CoordFormat;
-  BitField<9, 5, u32> Tex5Frac;
+  BitField<9, 5, u8, u32> Tex5Frac;
   // 14:22
   BitField<14, 1, TexComponentCount> Tex6CoordElements;
   BitField<15, 3, ComponentFormat> Tex6CoordFormat;
-  BitField<18, 5, u32> Tex6Frac;
+  BitField<18, 5, u8, u32> Tex6Frac;
   // 23:31
   BitField<23, 1, TexComponentCount> Tex7CoordElements;
   BitField<24, 3, ComponentFormat> Tex7CoordFormat;
-  BitField<27, 5, u32> Tex7Frac;
+  BitField<27, 5, u8, u32> Tex7Frac;
 };
 template <>
 struct fmt::formatter<UVAT_group2>
@@ -450,30 +450,123 @@ struct fmt::formatter<UVAT_group2>
   }
 };
 
-struct ColorAttr
+struct VAT
 {
-  ColorComponentCount Elements;
+  UVAT_group0 g0;
-  ColorFormat Comp;
+  UVAT_group1 g1;
-};
+  UVAT_group2 g2;
 
-struct TexAttr
+  constexpr ColorComponentCount GetColorElements(size_t idx) const
   {
-  TexComponentCount Elements;
+    switch (idx)
-  ComponentFormat Format;
+    {
-  u8 Frac;
+    case 0:
+      return g0.Color0Elements;
+    case 1:
+      return g0.Color1Elements;
+    default:
+      PanicAlertFmt("Invalid color index {}", idx);
+      return ColorComponentCount::RGB;
+    }
+  }
+  constexpr ColorFormat GetColorFormat(size_t idx) const
+  {
+    switch (idx)
+    {
+    case 0:
+      return g0.Color0Comp;
+    case 1:
+      return g0.Color1Comp;
+    default:
+      PanicAlertFmt("Invalid color index {}", idx);
+      return ColorFormat::RGB565;
+    }
+  }
+  constexpr TexComponentCount GetTexElements(size_t idx) const
+  {
+    switch (idx)
+    {
+    case 0:
+      return g0.Tex0CoordElements;
+    case 1:
+      return g1.Tex1CoordElements;
+    case 2:
+      return g1.Tex2CoordElements;
+    case 3:
+      return g1.Tex3CoordElements;
+    case 4:
+      return g1.Tex4CoordElements;
+    case 5:
+      return g2.Tex5CoordElements;
+    case 6:
+      return g2.Tex6CoordElements;
+    case 7:
+      return g2.Tex7CoordElements;
+    default:
+      PanicAlertFmt("Invalid tex coord index {}", idx);
+      return TexComponentCount::S;
+    }
+  }
+  constexpr ComponentFormat GetTexFormat(size_t idx) const
+  {
+    switch (idx)
+    {
+    case 0:
+      return g0.Tex0CoordFormat;
+    case 1:
+      return g1.Tex1CoordFormat;
+    case 2:
+      return g1.Tex2CoordFormat;
+    case 3:
+      return g1.Tex3CoordFormat;
+    case 4:
+      return g1.Tex4CoordFormat;
+    case 5:
+      return g2.Tex5CoordFormat;
+    case 6:
+      return g2.Tex6CoordFormat;
+    case 7:
+      return g2.Tex7CoordFormat;
+    default:
+      PanicAlertFmt("Invalid tex coord index {}", idx);
+      return ComponentFormat::UByte;
+    }
+  }
+  constexpr u8 GetTexFrac(size_t idx) const
+  {
+    switch (idx)
+    {
+    case 0:
+      return g0.Tex0Frac;
+    case 1:
+      return g1.Tex1Frac;
+    case 2:
+      return g1.Tex2Frac;
+    case 3:
+      return g1.Tex3Frac;
+    case 4:
+      return g2.Tex4Frac;
+    case 5:
+      return g2.Tex5Frac;
+    case 6:
+      return g2.Tex6Frac;
+    case 7:
+      return g2.Tex7Frac;
+    default:
+      PanicAlertFmt("Invalid tex coord index {}", idx);
+      return 0;
+    }
+  }
 };
-
+template <>
-struct TVtxAttr
+struct fmt::formatter<VAT>
 {
-  CoordComponentCount PosElements;
+  constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
-  ComponentFormat PosFormat;
+  template <typename FormatContext>
-  u8 PosFrac;
+  auto format(const VAT& vat, FormatContext& ctx)
-  NormalComponentCount NormalElements;
+  {
-  ComponentFormat NormalFormat;
+    return format_to(ctx.out(), "{}\n{}\n{}", vat.g0, vat.g1, vat.g2);
-  ColorAttr color[2];
+  }
-  TexAttr texCoord[8];
-  bool ByteDequant;
-  u8 NormalIndex3;
 };
 
 // Matrix indices
@@ -518,23 +611,6 @@ struct fmt::formatter<TMatrixIndexB>
   }
 };
 
-struct VAT
-{
-  UVAT_group0 g0;
-  UVAT_group1 g1;
-  UVAT_group2 g2;
-};
-template <>
-struct fmt::formatter<VAT>
-{
-  constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
-  template <typename FormatContext>
-  auto format(const VAT& vat, FormatContext& ctx)
-  {
-    return format_to(ctx.out(), "{}\n{}\n{}", vat.g0, vat.g1, vat.g2);
-  }
-};
-
 class VertexLoaderBase;
 
 // STATE_TO_SAVE

Source/Core/VideoCommon/VertexLoader.cpp

@@ -72,15 +72,14 @@ VertexLoader::VertexLoader(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
   CompileVertexTranslator();
 
   // generate frac factors
-  m_posScale = 1.0f / (1U << m_VtxAttr.PosFrac);
+  m_posScale = 1.0f / (1U << m_VtxAttr.g0.PosFrac);
-  for (int i = 0; i < 8; i++)
+  for (u32 i = 0; i < 8; i++)
-    m_tcScale[i] = 1.0f / (1U << m_VtxAttr.texCoord[i].Frac);
+    m_tcScale[i] = 1.0f / (1U << m_VtxAttr.GetTexFrac(i));
 }
 
 void VertexLoader::CompileVertexTranslator()
 {
   m_VertexSize = 0;
-  const TVtxAttr& vtx_attr = m_VtxAttr;
 
   // Reset pipeline
   m_numPipelineStages = 0;
@@ -154,12 +153,12 @@ void VertexLoader::CompileVertexTranslator()
   }
 
   // Write vertex position loader
-  WriteCall(VertexLoader_Position::GetFunction(m_VtxDesc.low.Position, m_VtxAttr.PosFormat,
+  WriteCall(VertexLoader_Position::GetFunction(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat,
-                                               m_VtxAttr.PosElements));
+                                               m_VtxAttr.g0.PosElements));
 
-  m_VertexSize += VertexLoader_Position::GetSize(m_VtxDesc.low.Position, m_VtxAttr.PosFormat,
+  m_VertexSize += VertexLoader_Position::GetSize(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat,
-                                                 m_VtxAttr.PosElements);
+                                                 m_VtxAttr.g0.PosElements);
-  int pos_elements = m_VtxAttr.PosElements == CoordComponentCount::XY ? 2 : 3;
+  int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3;
   m_native_vtx_decl.position.components = pos_elements;
   m_native_vtx_decl.position.enable = true;
   m_native_vtx_decl.position.offset = nat_offset;
@@ -170,22 +169,23 @@ void VertexLoader::CompileVertexTranslator()
   // Normals
   if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent)
   {
-    m_VertexSize += VertexLoader_Normal::GetSize(m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat,
+    m_VertexSize +=
-                                                 m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3);
+        VertexLoader_Normal::GetSize(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat,
+                                     m_VtxAttr.g0.NormalElements, m_VtxAttr.g0.NormalIndex3);
 
     TPipelineFunction pFunc =
-        VertexLoader_Normal::GetFunction(m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat,
+        VertexLoader_Normal::GetFunction(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat,
-                                         m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3);
+                                         m_VtxAttr.g0.NormalElements, m_VtxAttr.g0.NormalIndex3);
 
     if (pFunc == nullptr)
     {
       PanicAlertFmt("VertexLoader_Normal::GetFunction({} {} {} {}) returned zero!",
-                    m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements,
+                    m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, m_VtxAttr.g0.NormalElements,
-                    m_VtxAttr.NormalIndex3);
+                    m_VtxAttr.g0.NormalIndex3);
     }
     WriteCall(pFunc);
 
-    for (int i = 0; i < (vtx_attr.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++)
+    for (int i = 0; i < (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++)
     {
       m_native_vtx_decl.normals[i].components = 3;
       m_native_vtx_decl.normals[i].enable = true;
@@ -196,7 +196,7 @@ void VertexLoader::CompileVertexTranslator()
     }
 
     components |= VB_HAS_NRM0;
-    if (m_VtxAttr.NormalElements == NormalComponentCount::NBT)
+    if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT)
       components |= VB_HAS_NRM1 | VB_HAS_NRM2;
   }
 
@@ -206,9 +206,10 @@ void VertexLoader::CompileVertexTranslator()
     m_native_vtx_decl.colors[i].type = VAR_UNSIGNED_BYTE;
     m_native_vtx_decl.colors[i].integer = false;
 
-    m_VertexSize += VertexLoader_Color::GetSize(m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp);
+    m_VertexSize +=
+        VertexLoader_Color::GetSize(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i));
     TPipelineFunction pFunc =
-        VertexLoader_Color::GetFunction(m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp);
+        VertexLoader_Color::GetFunction(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i));
 
     if (pFunc != nullptr)
       WriteCall(pFunc);
@@ -232,8 +233,8 @@ void VertexLoader::CompileVertexTranslator()
     m_native_vtx_decl.texcoords[i].integer = false;
 
     const auto tc = m_VtxDesc.high.TexCoord[i].Value();
-    const auto format = m_VtxAttr.texCoord[i].Format;
+    const auto format = m_VtxAttr.GetTexFormat(i);
-    const auto elements = m_VtxAttr.texCoord[i].Elements;
+    const auto elements = m_VtxAttr.GetTexElements(i);
 
     if (tc != VertexComponentFormat::NotPresent)
     {
@@ -257,8 +258,7 @@ void VertexLoader::CompileVertexTranslator()
         // if texmtx is included, texcoord will always be 3 floats, z will be the texmtx index
         m_native_vtx_decl.texcoords[i].components = 3;
         nat_offset += 12;
-        WriteCall(m_VtxAttr.texCoord[i].Elements == TexComponentCount::ST ? TexMtx_Write_Float :
+        WriteCall(elements == TexComponentCount::ST ? TexMtx_Write_Float : TexMtx_Write_Float2);
-                                                                            TexMtx_Write_Float2);
       }
       else
       {
@@ -272,9 +272,8 @@ void VertexLoader::CompileVertexTranslator()
       if (tc != VertexComponentFormat::NotPresent)
       {
         m_native_vtx_decl.texcoords[i].enable = true;
-        m_native_vtx_decl.texcoords[i].components =
+        m_native_vtx_decl.texcoords[i].components = elements == TexComponentCount::ST ? 2 : 1;
-            vtx_attr.texCoord[i].Elements == TexComponentCount::ST ? 2 : 1;
+        nat_offset += 4 * (elements == TexComponentCount::ST ? 2 : 1);
-        nat_offset += 4 * (vtx_attr.texCoord[i].Elements == TexComponentCount::ST ? 2 : 1);
       }
     }
 

Source/Core/VideoCommon/VertexLoaderARM64.cpp

@@ -393,10 +393,11 @@ void VertexLoaderARM64::GenerateVertexLoader()
   for (size_t i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++)
   {
     has_tc |= m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent;
-    has_tc_scale |= !!m_VtxAttr.texCoord[i].Frac;
+    has_tc_scale |= (m_VtxAttr.GetTexFrac(i) != 0);
   }
 
-  bool need_scale = (m_VtxAttr.ByteDequant && m_VtxAttr.PosFrac) || (has_tc && has_tc_scale) ||
+  bool need_scale = (m_VtxAttr.g0.ByteDequant && m_VtxAttr.g0.PosFrac) ||
+                    (has_tc && has_tc_scale) ||
                     (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent);
 
   AlignCode16();
@@ -444,30 +445,30 @@ void VertexLoaderARM64::GenerateVertexLoader()
 
   // Position
   {
-    int elem_size = GetElementSize(m_VtxAttr.PosFormat);
+    int elem_size = GetElementSize(m_VtxAttr.g0.PosFormat);
-    int pos_elements = m_VtxAttr.PosElements == CoordComponentCount::XY ? 2 : 3;
+    int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3;
     int load_bytes = elem_size * pos_elements;
     int load_size = GetLoadSize(load_bytes);
     load_size <<= 3;
 
     s32 offset = GetAddressImm(ARRAY_POSITION, m_VtxDesc.low.Position, EncodeRegTo64(scratch1_reg),
                                load_size);
-    ReadVertex(m_VtxDesc.low.Position, m_VtxAttr.PosFormat, pos_elements, pos_elements,
+    ReadVertex(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, pos_elements, pos_elements,
-               m_VtxAttr.ByteDequant, m_VtxAttr.PosFrac, &m_native_vtx_decl.position, offset);
+               m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position, offset);
   }
 
   if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent)
   {
     static const u8 map[8] = {7, 6, 15, 14};
-    const u8 scaling_exponent = map[u32(m_VtxAttr.NormalFormat)];
+    const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())];
-    const int limit = m_VtxAttr.NormalElements == NormalComponentCount::NBT ? 3 : 1;
+    const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1;
 
     s32 offset = -1;
-    for (int i = 0; i < (m_VtxAttr.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++)
+    for (int i = 0; i < (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++)
     {
-      if (!i || m_VtxAttr.NormalIndex3)
+      if (!i || m_VtxAttr.g0.NormalIndex3)
       {
-        int elem_size = GetElementSize(m_VtxAttr.NormalFormat);
+        int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
 
         int load_bytes = elem_size * 3;
         int load_size = GetLoadSize(load_bytes);
@@ -480,7 +481,7 @@ void VertexLoaderARM64::GenerateVertexLoader()
         else
           offset += i * elem_size * 3;
       }
-      int bytes_read = ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, 3, 3, true,
+      int bytes_read = ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true,
                                   scaling_exponent, &m_native_vtx_decl.normals[i], offset);
 
       if (offset == -1)
@@ -490,7 +491,7 @@ void VertexLoaderARM64::GenerateVertexLoader()
     }
 
     m_native_components |= VB_HAS_NRM0;
-    if (m_VtxAttr.NormalElements == NormalComponentCount::NBT)
+    if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT)
       m_native_components |= VB_HAS_NRM1 | VB_HAS_NRM2;
   }
 
@@ -503,13 +504,13 @@ void VertexLoaderARM64::GenerateVertexLoader()
     if (m_VtxDesc.low.Color[i] != VertexComponentFormat::NotPresent)
     {
       u32 align = 4;
-      if (m_VtxAttr.color[i].Comp == ColorFormat::RGB565 ||
+      if (m_VtxAttr.GetColorFormat(i) == ColorFormat::RGB565 ||
-          m_VtxAttr.color[i].Comp == ColorFormat::RGBA4444)
+          m_VtxAttr.GetColorFormat(i) == ColorFormat::RGBA4444)
         align = 2;
 
       s32 offset = GetAddressImm(ARRAY_COLOR0 + int(i), m_VtxDesc.low.Color[i],
                                  EncodeRegTo64(scratch1_reg), align);
-      ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp, offset);
+      ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i), offset);
       m_native_components |= VB_HAS_COL0 << i;
       m_native_vtx_decl.colors[i].components = 4;
       m_native_vtx_decl.colors[i].enable = true;
@@ -526,22 +527,22 @@ void VertexLoaderARM64::GenerateVertexLoader()
     m_native_vtx_decl.texcoords[i].type = VAR_FLOAT;
     m_native_vtx_decl.texcoords[i].integer = false;
 
-    int elements = m_VtxAttr.texCoord[i].Elements == TexComponentCount::S ? 1 : 2;
+    int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::S ? 1 : 2;
     if (m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent)
     {
       m_native_components |= VB_HAS_UV0 << i;
 
-      int elem_size = GetElementSize(m_VtxAttr.texCoord[i].Format);
+      int elem_size = GetElementSize(m_VtxAttr.GetTexFormat(i));
       int load_bytes = elem_size * (elements + 2);
       int load_size = GetLoadSize(load_bytes);
       load_size <<= 3;
 
       s32 offset = GetAddressImm(ARRAY_TEXCOORD0 + int(i), m_VtxDesc.high.TexCoord[i],
                                  EncodeRegTo64(scratch1_reg), load_size);
-      u8 scaling_exponent = m_VtxAttr.texCoord[i].Frac;
+      u8 scaling_exponent = m_VtxAttr.GetTexFrac(i);
-      ReadVertex(m_VtxDesc.high.TexCoord[i], m_VtxAttr.texCoord[i].Format, elements,
+      ReadVertex(m_VtxDesc.high.TexCoord[i], m_VtxAttr.GetTexFormat(i), elements,
-                 m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.ByteDequant, scaling_exponent,
+                 m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.g0.ByteDequant,
-                 &m_native_vtx_decl.texcoords[i], offset);
+                 scaling_exponent, &m_native_vtx_decl.texcoords[i], offset);
     }
     if (m_VtxDesc.low.TexMatIdx[i])
     {

Source/Core/VideoCommon/VertexLoaderBase.cpp

@@ -26,53 +26,6 @@
 #include "VideoCommon/VertexLoaderARM64.h"
 #endif
 
-VertexLoaderBase::VertexLoaderBase(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
-    : m_VtxDesc{vtx_desc}, m_vat{vtx_attr}
-{
-  SetVAT(vtx_attr);
-}
-
-void VertexLoaderBase::SetVAT(const VAT& vat)
-{
-  m_VtxAttr.PosElements = vat.g0.PosElements;
-  m_VtxAttr.PosFormat = vat.g0.PosFormat;
-  m_VtxAttr.PosFrac = vat.g0.PosFrac;
-  m_VtxAttr.NormalElements = vat.g0.NormalElements;
-  m_VtxAttr.NormalFormat = vat.g0.NormalFormat;
-  m_VtxAttr.color[0].Elements = vat.g0.Color0Elements;
-  m_VtxAttr.color[0].Comp = vat.g0.Color0Comp;
-  m_VtxAttr.color[1].Elements = vat.g0.Color1Elements;
-  m_VtxAttr.color[1].Comp = vat.g0.Color1Comp;
-  m_VtxAttr.texCoord[0].Elements = vat.g0.Tex0CoordElements;
-  m_VtxAttr.texCoord[0].Format = vat.g0.Tex0CoordFormat;
-  m_VtxAttr.texCoord[0].Frac = vat.g0.Tex0Frac;
-  m_VtxAttr.ByteDequant = vat.g0.ByteDequant;
-  m_VtxAttr.NormalIndex3 = vat.g0.NormalIndex3;
-
-  m_VtxAttr.texCoord[1].Elements = vat.g1.Tex1CoordElements;
-  m_VtxAttr.texCoord[1].Format = vat.g1.Tex1CoordFormat;
-  m_VtxAttr.texCoord[1].Frac = vat.g1.Tex1Frac;
-  m_VtxAttr.texCoord[2].Elements = vat.g1.Tex2CoordElements;
-  m_VtxAttr.texCoord[2].Format = vat.g1.Tex2CoordFormat;
-  m_VtxAttr.texCoord[2].Frac = vat.g1.Tex2Frac;
-  m_VtxAttr.texCoord[3].Elements = vat.g1.Tex3CoordElements;
-  m_VtxAttr.texCoord[3].Format = vat.g1.Tex3CoordFormat;
-  m_VtxAttr.texCoord[3].Frac = vat.g1.Tex3Frac;
-  m_VtxAttr.texCoord[4].Elements = vat.g1.Tex4CoordElements;
-  m_VtxAttr.texCoord[4].Format = vat.g1.Tex4CoordFormat;
-
-  m_VtxAttr.texCoord[4].Frac = vat.g2.Tex4Frac;
-  m_VtxAttr.texCoord[5].Elements = vat.g2.Tex5CoordElements;
-  m_VtxAttr.texCoord[5].Format = vat.g2.Tex5CoordFormat;
-  m_VtxAttr.texCoord[5].Frac = vat.g2.Tex5Frac;
-  m_VtxAttr.texCoord[6].Elements = vat.g2.Tex6CoordElements;
-  m_VtxAttr.texCoord[6].Format = vat.g2.Tex6CoordFormat;
-  m_VtxAttr.texCoord[6].Frac = vat.g2.Tex6Frac;
-  m_VtxAttr.texCoord[7].Elements = vat.g2.Tex7CoordElements;
-  m_VtxAttr.texCoord[7].Format = vat.g2.Tex7CoordFormat;
-  m_VtxAttr.texCoord[7].Frac = vat.g2.Tex7Frac;
-};
-
 // a hacky implementation to compare two vertex loaders
 class VertexLoaderTester : public VertexLoaderBase
 {
@@ -130,8 +83,8 @@ public:
       ERROR_LOG_FMT(VIDEO,
                     "The two vertex loaders have loaded different data "
                     "(guru meditation {:#010x}, {:#010x}, {:#010x}, {:#010x}, {:#010x}).",
-                    m_VtxDesc.low.Hex, m_VtxDesc.high.Hex, m_vat.g0.Hex, m_vat.g1.Hex,
+                    m_VtxDesc.low.Hex, m_VtxDesc.high.Hex, m_VtxAttr.g0.Hex, m_VtxAttr.g1.Hex,
-                    m_vat.g2.Hex);
+                    m_VtxAttr.g2.Hex);
     }
 
     memcpy(dst.GetPointer(), buffer_a.data(), count_a * m_native_vtx_decl.stride);

Source/Core/VideoCommon/VertexLoaderBase.h

@@ -77,11 +77,10 @@ public:
   int m_numLoadedVertices = 0;
 
 protected:
-  VertexLoaderBase(const TVtxDesc& vtx_desc, const VAT& vtx_attr);
+  VertexLoaderBase(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
-  void SetVAT(const VAT& vat);
+      : m_VtxDesc{vtx_desc}, m_VtxAttr{vtx_attr} {};
 
   // GC vertex format
-  TVtxAttr m_VtxAttr;  // VAT decoded into easy format
+  const VAT m_VtxAttr;
-  TVtxDesc m_VtxDesc;  // Not really used currently - or well it is, but could be easily avoided.
+  const TVtxDesc m_VtxDesc;
-  VAT m_vat;
 };

Source/Core/VideoCommon/VertexLoaderX64.cpp

@@ -439,30 +439,30 @@ void VertexLoaderX64::GenerateVertexLoader()
   }
 
   OpArg data = GetVertexAddr(ARRAY_POSITION, m_VtxDesc.low.Position);
-  int pos_elements = m_VtxAttr.PosElements == CoordComponentCount::XY ? 2 : 3;
+  int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3;
-  ReadVertex(data, m_VtxDesc.low.Position, m_VtxAttr.PosFormat, pos_elements, pos_elements,
+  ReadVertex(data, m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, pos_elements, pos_elements,
-             m_VtxAttr.ByteDequant, m_VtxAttr.PosFrac, &m_native_vtx_decl.position);
+             m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position);
 
   if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent)
   {
     static const u8 map[8] = {7, 6, 15, 14};
-    const u8 scaling_exponent = map[u32(m_VtxAttr.NormalFormat)];
+    const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())];
-    const int limit = m_VtxAttr.NormalElements == NormalComponentCount::NBT ? 3 : 1;
+    const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1;
 
     for (int i = 0; i < limit; i++)
     {
-      if (!i || m_VtxAttr.NormalIndex3)
+      if (!i || m_VtxAttr.g0.NormalIndex3)
       {
         data = GetVertexAddr(ARRAY_NORMAL, m_VtxDesc.low.Normal);
-        int elem_size = GetElementSize(m_VtxAttr.NormalFormat);
+        int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
         data.AddMemOffset(i * elem_size * 3);
       }
-      data.AddMemOffset(ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, 3, 3, true,
+      data.AddMemOffset(ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3,
-                                   scaling_exponent, &m_native_vtx_decl.normals[i]));
+                                   true, scaling_exponent, &m_native_vtx_decl.normals[i]));
     }
 
     m_native_components |= VB_HAS_NRM0;
-    if (m_VtxAttr.NormalElements == NormalComponentCount::NBT)
+    if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT)
       m_native_components |= VB_HAS_NRM1 | VB_HAS_NRM2;
   }
 
@@ -471,7 +471,7 @@ void VertexLoaderX64::GenerateVertexLoader()
     if (m_VtxDesc.low.Color[i] != VertexComponentFormat::NotPresent)
     {
       data = GetVertexAddr(ARRAY_COLOR0 + int(i), m_VtxDesc.low.Color[i]);
-      ReadColor(data, m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp);
+      ReadColor(data, m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i));
       m_native_components |= VB_HAS_COL0 << i;
       m_native_vtx_decl.colors[i].components = 4;
       m_native_vtx_decl.colors[i].enable = true;
@@ -484,14 +484,14 @@ void VertexLoaderX64::GenerateVertexLoader()
 
   for (size_t i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++)
   {
-    int elements = m_VtxAttr.texCoord[i].Elements == TexComponentCount::ST ? 2 : 1;
+    int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::ST ? 2 : 1;
     if (m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent)
     {
       data = GetVertexAddr(ARRAY_TEXCOORD0 + int(i), m_VtxDesc.high.TexCoord[i]);
-      u8 scaling_exponent = m_VtxAttr.texCoord[i].Frac;
+      u8 scaling_exponent = m_VtxAttr.GetTexFrac(i);
-      ReadVertex(data, m_VtxDesc.high.TexCoord[i], m_VtxAttr.texCoord[i].Format, elements,
+      ReadVertex(data, m_VtxDesc.high.TexCoord[i], m_VtxAttr.GetTexFormat(i), elements,
-                 m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.ByteDequant, scaling_exponent,
+                 m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.g0.ByteDequant,
-                 &m_native_vtx_decl.texcoords[i]);
+                 scaling_exponent, &m_native_vtx_decl.texcoords[i]);
       m_native_components |= VB_HAS_UV0 << i;
     }
     if (m_VtxDesc.low.TexMatIdx[i])