Reformat all the things!

19 files changed, 310 insertions, 136 deletions

diff --git a/Source/Core/VideoCommon/AsyncRequests.h b/Source/Core/VideoCommon/AsyncRequests.h
index 4c22d388e3..acd665b3b1 100644
--- a/Source/Core/VideoCommon/AsyncRequests.h
+++ b/Source/Core/VideoCommon/AsyncRequests.h
@@ -79,6 +79,7 @@ public:
   void SetPassthrough(bool enable);
 
   static AsyncRequests* GetInstance() { return &s_singleton; }
+
 private:
   void PullEventsInternal();
   void HandleEvent(const Event& e);
diff --git a/Source/Core/VideoCommon/BPStructs.cpp b/Source/Core/VideoCommon/BPStructs.cpp
index 0078633b08..4647c3de4e 100644
--- a/Source/Core/VideoCommon/BPStructs.cpp
+++ b/Source/Core/VideoCommon/BPStructs.cpp
@@ -253,8 +253,9 @@ static void BPWritten(const BPCmd& bp)
 
       u32 height = static_cast<u32>(num_xfb_lines);
 
-      DEBUG_LOG(VIDEO, "RenderToXFB: destAddr: %08x | srcRect {%d %d %d %d} | fbWidth: %u | "
-                       "fbStride: %u | fbHeight: %u | yScale: %f",
+      DEBUG_LOG(VIDEO,
+                "RenderToXFB: destAddr: %08x | srcRect {%d %d %d %d} | fbWidth: %u | "
+                "fbStride: %u | fbHeight: %u | yScale: %f",
                 destAddr, srcRect.left, srcRect.top, srcRect.right, srcRect.bottom,
                 bpmem.copyTexSrcWH.x + 1, destStride, height, yScale);
 
@@ -1002,27 +1003,28 @@ void GetBPRegInfo(const u8* data, std::string* name, std::string* desc)
     SetRegName(BPMEM_TRIGGER_EFB_COPY);
     UPE_Copy copy;
     copy.Hex = cmddata;
-    *desc = StringFromFormat("Clamping: %s\n"
-                             "Converting from RGB to YUV: %s\n"
-                             "Target pixel format: 0x%X\n"
-                             "Gamma correction: %s\n"
-                             "Mipmap filter: %s\n"
-                             "Vertical scaling: %s\n"
-                             "Clear: %s\n"
-                             "Frame to field: 0x%01X\n"
-                             "Copy to XFB: %s\n"
-                             "Intensity format: %s\n"
-                             "Automatic color conversion: %s",
-                             (copy.clamp0 && copy.clamp1) ? "Top and Bottom" : (copy.clamp0) ?
-                                                            "Top only" :
-                                                            (copy.clamp1) ? "Bottom only" : "None",
-                             no_yes[copy.yuv], static_cast<int>(copy.tp_realFormat()),
-                             (copy.gamma == 0) ? "1.0" : (copy.gamma == 1) ?
-                                                 "1.7" :
-                                                 (copy.gamma == 2) ? "2.2" : "Invalid value 0x3?",
-                             no_yes[copy.half_scale], no_yes[copy.scale_invert], no_yes[copy.clear],
-                             (u32)copy.frame_to_field, no_yes[copy.copy_to_xfb],
-                             no_yes[copy.intensity_fmt], no_yes[copy.auto_conv]);
+    *desc = StringFromFormat(
+        "Clamping: %s\n"
+        "Converting from RGB to YUV: %s\n"
+        "Target pixel format: 0x%X\n"
+        "Gamma correction: %s\n"
+        "Mipmap filter: %s\n"
+        "Vertical scaling: %s\n"
+        "Clear: %s\n"
+        "Frame to field: 0x%01X\n"
+        "Copy to XFB: %s\n"
+        "Intensity format: %s\n"
+        "Automatic color conversion: %s",
+        (copy.clamp0 && copy.clamp1) ?
+            "Top and Bottom" :
+            (copy.clamp0) ? "Top only" : (copy.clamp1) ? "Bottom only" : "None",
+        no_yes[copy.yuv], static_cast<int>(copy.tp_realFormat()),
+        (copy.gamma == 0) ?
+            "1.0" :
+            (copy.gamma == 1) ? "1.7" : (copy.gamma == 2) ? "2.2" : "Invalid value 0x3?",
+        no_yes[copy.half_scale], no_yes[copy.scale_invert], no_yes[copy.clear],
+        (u32)copy.frame_to_field, no_yes[copy.copy_to_xfb], no_yes[copy.intensity_fmt],
+        no_yes[copy.auto_conv]);
   }
   break;
 
diff --git a/Source/Core/VideoCommon/FPSCounter.h b/Source/Core/VideoCommon/FPSCounter.h
index 112256e414..a539c690ab 100644
--- a/Source/Core/VideoCommon/FPSCounter.h
+++ b/Source/Core/VideoCommon/FPSCounter.h
@@ -18,6 +18,7 @@ public:
   void Update();
 
   float GetFPS() const { return m_fps; }
+
 private:
   u64 m_last_time = 0;
   u64 m_time_since_update = 0;
diff --git a/Source/Core/VideoCommon/FramebufferManagerBase.h b/Source/Core/VideoCommon/FramebufferManagerBase.h
index a008d49e92..c77b741e41 100644
--- a/Source/Core/VideoCommon/FramebufferManagerBase.h
+++ b/Source/Core/VideoCommon/FramebufferManagerBase.h
@@ -19,6 +19,7 @@ public:
   virtual ~FramebufferManagerBase();
 
   static unsigned int GetEFBLayers() { return m_EFBLayers; }
+
 protected:
   static unsigned int m_EFBLayers;
 };
diff --git a/Source/Core/VideoCommon/HiresTextures.cpp b/Source/Core/VideoCommon/HiresTextures.cpp
index 26afccbaa9..6a45f812fa 100644
--- a/Source/Core/VideoCommon/HiresTextures.cpp
+++ b/Source/Core/VideoCommon/HiresTextures.cpp
@@ -379,16 +379,18 @@ std::unique_ptr<HiresTexture> HiresTexture::Load(const std::string& base_filenam
   const Level& first_mip = ret->m_levels[0];
   if (first_mip.width * height != first_mip.height * width)
   {
-    ERROR_LOG(VIDEO, "Invalid custom texture size %ux%u for texture %s. The aspect differs "
-                     "from the native size %ux%u.",
+    ERROR_LOG(VIDEO,
+              "Invalid custom texture size %ux%u for texture %s. The aspect differs "
+              "from the native size %ux%u.",
               first_mip.width, first_mip.height, first_mip_file.path.c_str(), width, height);
   }
 
   // Same deal if the custom texture isn't a multiple of the native size.
   if (width != 0 && height != 0 && (first_mip.width % width || first_mip.height % height))
   {
-    ERROR_LOG(VIDEO, "Invalid custom texture size %ux%u for texture %s. Please use an integer "
-                     "upscaling factor based on the native size %ux%u.",
+    ERROR_LOG(VIDEO,
+              "Invalid custom texture size %ux%u for texture %s. Please use an integer "
+              "upscaling factor based on the native size %ux%u.",
               first_mip.width, first_mip.height, first_mip_file.path.c_str(), width, height);
   }
 
diff --git a/Source/Core/VideoCommon/NativeVertexFormat.h b/Source/Core/VideoCommon/NativeVertexFormat.h
index ac75f68652..e7b575a587 100644
--- a/Source/Core/VideoCommon/NativeVertexFormat.h
+++ b/Source/Core/VideoCommon/NativeVertexFormat.h
@@ -112,6 +112,7 @@ public:
 
   u32 GetVertexStride() const { return vtx_decl.stride; }
   const PortableVertexDeclaration& GetVertexDeclaration() const { return vtx_decl; }
+
 protected:
   // Let subclasses construct.
   NativeVertexFormat() {}
diff --git a/Source/Core/VideoCommon/PerfQueryBase.h b/Source/Core/VideoCommon/PerfQueryBase.h
index ea74c2d57a..449b86cc1b 100644
--- a/Source/Core/VideoCommon/PerfQueryBase.h
+++ b/Source/Core/VideoCommon/PerfQueryBase.h
@@ -50,6 +50,7 @@ public:
   // True if there are no further pending query results
   // NOTE: Called from CPU thread
   virtual bool IsFlushed() const { return true; }
+
 protected:
   // TODO: sloppy
   volatile u32 m_query_count;
diff --git a/Source/Core/VideoCommon/PixelShaderGen.cpp b/Source/Core/VideoCommon/PixelShaderGen.cpp
index 61c39a54fe..aae881a0f1 100644
--- a/Source/Core/VideoCommon/PixelShaderGen.cpp
+++ b/Source/Core/VideoCommon/PixelShaderGen.cpp
@@ -1194,7 +1194,10 @@ static void WriteTevRegular(ShaderCode& out, const char* components, int bias, i
 
   const char* tevLerpBias[] =  // indexed by 2*op+(shift==3)
       {
-          "", " + 128", "", " + 127",
+          "",
+          " + 128",
+          "",
+          " + 127",
       };
 
   const char* tevBiasTable[] = {
diff --git a/Source/Core/VideoCommon/PostProcessing.h b/Source/Core/VideoCommon/PostProcessing.h
index 4a51e66842..f453fff587 100644
--- a/Source/Core/VideoCommon/PostProcessing.h
+++ b/Source/Core/VideoCommon/PostProcessing.h
@@ -87,6 +87,7 @@ public:
   static std::vector<std::string> GetAnaglyphShaderList(APIType api_type);
 
   PostProcessingShaderConfiguration* GetConfig() { return &m_config; }
+
 protected:
   // Timer for determining our time value
   Common::Timer m_timer;
diff --git a/Source/Core/VideoCommon/ShaderCache.cpp b/Source/Core/VideoCommon/ShaderCache.cpp
index cd7ec4ced9..6ab6f17fa5 100644
--- a/Source/Core/VideoCommon/ShaderCache.cpp
+++ b/Source/Core/VideoCommon/ShaderCache.cpp
@@ -680,6 +680,7 @@ void ShaderCache::QueueVertexShaderCompile(const VertexShaderUid& uid, u32 prior
     }
 
     void Retrieve() override { shader_cache->InsertVertexShader(uid, std::move(shader)); }
+
   private:
     ShaderCache* shader_cache;
     std::unique_ptr<AbstractShader> shader;
@@ -708,6 +709,7 @@ void ShaderCache::QueueVertexUberShaderCompile(const UberShader::VertexShaderUid
     }
 
     void Retrieve() override { shader_cache->InsertVertexUberShader(uid, std::move(shader)); }
+
   private:
     ShaderCache* shader_cache;
     std::unique_ptr<AbstractShader> shader;
@@ -736,6 +738,7 @@ void ShaderCache::QueuePixelShaderCompile(const PixelShaderUid& uid, u32 priorit
     }
 
     void Retrieve() override { shader_cache->InsertPixelShader(uid, std::move(shader)); }
+
   private:
     ShaderCache* shader_cache;
     std::unique_ptr<AbstractShader> shader;
@@ -764,6 +767,7 @@ void ShaderCache::QueuePixelUberShaderCompile(const UberShader::PixelShaderUid&
     }
 
     void Retrieve() override { shader_cache->InsertPixelUberShader(uid, std::move(shader)); }
+
   private:
     ShaderCache* shader_cache;
     std::unique_ptr<AbstractShader> shader;
diff --git a/Source/Core/VideoCommon/ShaderGenCommon.h b/Source/Core/VideoCommon/ShaderGenCommon.h
index af9b97cf2f..ad5604127c 100644
--- a/Source/Core/VideoCommon/ShaderGenCommon.h
+++ b/Source/Core/VideoCommon/ShaderGenCommon.h
@@ -98,6 +98,7 @@ public:
   const uid_data* GetUidData() const { return &data; }
   const u8* GetUidDataRaw() const { return &values[0]; }
   size_t GetUidDataSize() const { return sizeof(values); }
+
 private:
   union
   {
diff --git a/Source/Core/VideoCommon/TextureCacheBase.cpp b/Source/Core/VideoCommon/TextureCacheBase.cpp
index 278d2486b9..9ac75d31f0 100644
--- a/Source/Core/VideoCommon/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/TextureCacheBase.cpp
@@ -573,8 +573,10 @@ private:
           auto x = j * 2;
           auto y = i * 2;
           const std::array<PixelRGBAf, 4> samples{{
-              Sample(src, src_shape, x, y), Sample(src, src_shape, x + 1, y),
-              Sample(src, src_shape, x, y + 1), Sample(src, src_shape, x + 1, y + 1),
+              Sample(src, src_shape, x, y),
+              Sample(src, src_shape, x + 1, y),
+              Sample(src, src_shape, x, y + 1),
+              Sample(src, src_shape, x + 1, y + 1),
           }};
 
           auto* dst_pixel = dst + (j + i * dst_shape.row_length) * 4;
diff --git a/Source/Core/VideoCommon/TextureDecoder_Common.cpp b/Source/Core/VideoCommon/TextureDecoder_Common.cpp
index 9dd9f5850c..2e84e3d282 100644
--- a/Source/Core/VideoCommon/TextureDecoder_Common.cpp
+++ b/Source/Core/VideoCommon/TextureDecoder_Common.cpp
@@ -259,17 +259,73 @@ void TexDecoder_SetTexFmtOverlayOptions(bool enable, bool center)
 
 static const char* texfmt[] = {
     // pixel
-    "I4", "I8", "IA4", "IA8", "RGB565", "RGB5A3", "RGBA8", "0x07", "C4", "C8", "C14X2", "0x0B",
-    "0x0C", "0x0D", "CMPR", "0x0F",
+    "I4",
+    "I8",
+    "IA4",
+    "IA8",
+    "RGB565",
+    "RGB5A3",
+    "RGBA8",
+    "0x07",
+    "C4",
+    "C8",
+    "C14X2",
+    "0x0B",
+    "0x0C",
+    "0x0D",
+    "CMPR",
+    "0x0F",
     // Z-buffer
-    "0x10", "Z8", "0x12", "Z16", "0x14", "0x15", "Z24X8", "0x17", "0x18", "0x19", "0x1A", "0x1B",
-    "0x1C", "0x1D", "0x1E", "0x1F",
+    "0x10",
+    "Z8",
+    "0x12",
+    "Z16",
+    "0x14",
+    "0x15",
+    "Z24X8",
+    "0x17",
+    "0x18",
+    "0x19",
+    "0x1A",
+    "0x1B",
+    "0x1C",
+    "0x1D",
+    "0x1E",
+    "0x1F",
     // pixel + copy
-    "CR4", "0x21", "CRA4", "CRA8", "0x24", "0x25", "CYUVA8", "CA8", "CR8", "CG8", "CB8", "CRG8",
-    "CGB8", "0x2D", "0x2E", "XFB",
+    "CR4",
+    "0x21",
+    "CRA4",
+    "CRA8",
+    "0x24",
+    "0x25",
+    "CYUVA8",
+    "CA8",
+    "CR8",
+    "CG8",
+    "CB8",
+    "CRG8",
+    "CGB8",
+    "0x2D",
+    "0x2E",
+    "XFB",
     // Z + copy
-    "CZ4", "0x31", "0x32", "0x33", "0x34", "0x35", "0x36", "0x37", "0x38", "CZ8M", "CZ8L", "0x3B",
-    "CZ16L", "0x3D", "0x3E", "0x3F",
+    "CZ4",
+    "0x31",
+    "0x32",
+    "0x33",
+    "0x34",
+    "0x35",
+    "0x36",
+    "0x37",
+    "0x38",
+    "CZ8M",
+    "CZ8L",
+    "0x3B",
+    "CZ16L",
+    "0x3D",
+    "0x3E",
+    "0x3F",
 };
 
 static void TexDecoder_DrawOverlay(u8* dst, int width, int height, TextureFormat texformat)
diff --git a/Source/Core/VideoCommon/UberShaderPixel.cpp b/Source/Core/VideoCommon/UberShaderPixel.cpp
index 76aeab8dd7..4b680fee2e 100644
--- a/Source/Core/VideoCommon/UberShaderPixel.cpp
+++ b/Source/Core/VideoCommon/UberShaderPixel.cpp
@@ -924,9 +924,8 @@ ShaderCode GenPixelShader(APIType ApiType, const ShaderHostConfig& host_config,
             "      int3 color_D = selectColorInput(s, ss, %scolors_0, %scolors_1, color_d);  // 10 "
             "bits + sign\n"
             "\n",  // TODO: do we need to sign extend?
-            color_input_prefix,
             color_input_prefix, color_input_prefix, color_input_prefix, color_input_prefix,
-            color_input_prefix, color_input_prefix, color_input_prefix);
+            color_input_prefix, color_input_prefix, color_input_prefix, color_input_prefix);
   out.Write(
       "      int3 color;\n"
       "      if(color_bias != 3u) { // Normal mode\n"
@@ -998,9 +997,8 @@ ShaderCode GenPixelShader(APIType ApiType, const ShaderHostConfig& host_config,
       "      int alpha_D = selectAlphaInput(s, ss, %scolors_0, %scolors_1, alpha_d); // 10 bits + "
       "sign\n"
       "\n",  // TODO: do we need to sign extend?
-      color_input_prefix,
       color_input_prefix, color_input_prefix, color_input_prefix, color_input_prefix,
-      color_input_prefix, color_input_prefix, color_input_prefix);
+      color_input_prefix, color_input_prefix, color_input_prefix, color_input_prefix);
   out.Write("\n"
             "      int alpha;\n"
             "      if(alpha_bias != 3u) { // Normal mode\n"
diff --git a/Source/Core/VideoCommon/VertexLoaderARM64.cpp b/Source/Core/VideoCommon/VertexLoaderARM64.cpp
index a1c8783581..22e695a066 100644
--- a/Source/Core/VideoCommon/VertexLoaderARM64.cpp
+++ b/Source/Core/VideoCommon/VertexLoaderARM64.cpp
@@ -461,9 +461,9 @@ void VertexLoaderARM64::GenerateVertexLoader()
         int elem_size = 1 << (m_VtxAttr.NormalFormat / 2);
 
         int load_bytes = elem_size * 3;
-        int load_size = load_bytes == 1 ? 1 : load_bytes <= 2 ? 2 : load_bytes <= 4 ?
-                                                                4 :
-                                                                load_bytes <= 8 ? 8 : 16;
+        int load_size = load_bytes == 1 ?
+                            1 :
+                            load_bytes <= 2 ? 2 : load_bytes <= 4 ? 4 : load_bytes <= 8 ? 8 : 16;
 
         offset = GetAddressImm(ARRAY_NORMAL, m_VtxDesc.Normal, EncodeRegTo64(scratch1_reg),
                                load_size << 3);
@@ -525,9 +525,9 @@ void VertexLoaderARM64::GenerateVertexLoader()
 
       int elem_size = 1 << (m_VtxAttr.texCoord[i].Format / 2);
       int load_bytes = elem_size * (elements + 2);
-      int load_size = load_bytes == 1 ? 1 : load_bytes <= 2 ? 2 : load_bytes <= 4 ?
-                                                              4 :
-                                                              load_bytes <= 8 ? 8 : 16;
+      int load_size = load_bytes == 1 ?
+                          1 :
+                          load_bytes <= 2 ? 2 : load_bytes <= 4 ? 4 : load_bytes <= 8 ? 8 : 16;
       load_size <<= 3;
 
       s32 offset =
@@ -611,6 +611,6 @@ void VertexLoaderARM64::GenerateVertexLoader()
 int VertexLoaderARM64::RunVertices(DataReader src, DataReader dst, int count)
 {
   m_numLoadedVertices += count;
-  return ((int (*)(u8 * src, u8 * dst, int count))region)(src.GetPointer(), dst.GetPointer(),
-                                                          count);
+  return ((int (*)(u8 * src, u8 * dst, int count)) region)(src.GetPointer(), dst.GetPointer(),
+                                                           count);
 }
diff --git a/Source/Core/VideoCommon/VertexLoaderBase.cpp b/Source/Core/VideoCommon/VertexLoaderBase.cpp
index 21a149c169..141078f676 100644
--- a/Source/Core/VideoCommon/VertexLoaderBase.cpp
+++ b/Source/Core/VideoCommon/VertexLoaderBase.cpp
@@ -81,13 +81,30 @@ std::string VertexLoaderBase::ToString() const
   dest += ": ";
 
   static constexpr std::array<const char*, 4> pos_mode{{
-      "Inv", "Dir", "I8", "I16",
+      "Inv",
+      "Dir",
+      "I8",
+      "I16",
   }};
   static constexpr std::array<const char*, 8> pos_formats{{
-      "u8", "s8", "u16", "s16", "flt", "Inv", "Inv", "Inv",
+      "u8",
+      "s8",
+      "u16",
+      "s16",
+      "flt",
+      "Inv",
+      "Inv",
+      "Inv",
   }};
   static constexpr std::array<const char*, 8> color_format{{
-      "565", "888", "888x", "4444", "6666", "8888", "Inv", "Inv",
+      "565",
+      "888",
+      "888x",
+      "4444",
+      "6666",
+      "8888",
+      "Inv",
+      "Inv",
   }};
 
   dest += StringFromFormat("%ib skin: %i P: %i %s-%s ", m_VertexSize, (u32)m_VtxDesc.PosMatIdx,
@@ -174,8 +191,9 @@ public:
 
     if (memcmp(buffer_a.data(), buffer_b.data(),
                std::min(count_a, count_b) * m_native_vtx_decl.stride))
-      ERROR_LOG(VIDEO, "The two vertex loaders have loaded different data "
-                       "(guru meditation 0x%016" PRIx64 ", 0x%08x, 0x%08x, 0x%08x).",
+      ERROR_LOG(VIDEO,
+                "The two vertex loaders have loaded different data "
+                "(guru meditation 0x%016" PRIx64 ", 0x%08x, 0x%08x, 0x%08x).",
                 m_VtxDesc.Hex, m_vat.g0.Hex, m_vat.g1.Hex, m_vat.g2.Hex);
 
     memcpy(dst.GetPointer(), buffer_a.data(), count_a * m_native_vtx_decl.stride);
@@ -184,6 +202,7 @@ public:
   }
   std::string GetName() const override { return "CompareLoader"; }
   bool IsInitialized() override { return m_initialized; }
+
 private:
   bool m_initialized;
 
@@ -199,7 +218,7 @@ std::unique_ptr<VertexLoaderBase> VertexLoaderBase::CreateVertexLoader(const TVt
 {
   std::unique_ptr<VertexLoaderBase> loader;
 
-//#define COMPARE_VERTEXLOADERS
+  //#define COMPARE_VERTEXLOADERS
 
 #if defined(COMPARE_VERTEXLOADERS) && defined(_M_X86_64)
   // first try: Any new VertexLoader vs the old one
diff --git a/Source/Core/VideoCommon/VertexLoaderBase.h b/Source/Core/VideoCommon/VertexLoaderBase.h
index 509ccb4310..5e1ffc4fd2 100644
--- a/Source/Core/VideoCommon/VertexLoaderBase.h
+++ b/Source/Core/VideoCommon/VertexLoaderBase.h
@@ -33,6 +33,7 @@ public:
 
   bool operator==(const VertexLoaderUID& rh) const { return vid == rh.vid; }
   size_t GetHash() const { return hash; }
+
 private:
   size_t CalculateHash() const
   {
diff --git a/Source/Core/VideoCommon/VertexLoader_Position.cpp b/Source/Core/VideoCommon/VertexLoader_Position.cpp
index 86f1e76e36..a21061ac55 100644
--- a/Source/Core/VideoCommon/VertexLoader_Position.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_Position.cpp
@@ -78,70 +78,90 @@ void Pos_ReadIndex(VertexLoader* loader)
 static TPipelineFunction tableReadPosition[4][8][2] = {
     {
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
     },
     {
         {
-            Pos_ReadDirect<u8, 2>, Pos_ReadDirect<u8, 3>,
+            Pos_ReadDirect<u8, 2>,
+            Pos_ReadDirect<u8, 3>,
         },
         {
-            Pos_ReadDirect<s8, 2>, Pos_ReadDirect<s8, 3>,
+            Pos_ReadDirect<s8, 2>,
+            Pos_ReadDirect<s8, 3>,
         },
         {
-            Pos_ReadDirect<u16, 2>, Pos_ReadDirect<u16, 3>,
+            Pos_ReadDirect<u16, 2>,
+            Pos_ReadDirect<u16, 3>,
         },
         {
-            Pos_ReadDirect<s16, 2>, Pos_ReadDirect<s16, 3>,
+            Pos_ReadDirect<s16, 2>,
+            Pos_ReadDirect<s16, 3>,
         },
         {
-            Pos_ReadDirect<float, 2>, Pos_ReadDirect<float, 3>,
+            Pos_ReadDirect<float, 2>,
+            Pos_ReadDirect<float, 3>,
         },
     },
     {
         {
-            Pos_ReadIndex<u8, u8, 2>, Pos_ReadIndex<u8, u8, 3>,
+            Pos_ReadIndex<u8, u8, 2>,
+            Pos_ReadIndex<u8, u8, 3>,
         },
         {
-            Pos_ReadIndex<u8, s8, 2>, Pos_ReadIndex<u8, s8, 3>,
+            Pos_ReadIndex<u8, s8, 2>,
+            Pos_ReadIndex<u8, s8, 3>,
         },
         {
-            Pos_ReadIndex<u8, u16, 2>, Pos_ReadIndex<u8, u16, 3>,
+            Pos_ReadIndex<u8, u16, 2>,
+            Pos_ReadIndex<u8, u16, 3>,
         },
         {
-            Pos_ReadIndex<u8, s16, 2>, Pos_ReadIndex<u8, s16, 3>,
+            Pos_ReadIndex<u8, s16, 2>,
+            Pos_ReadIndex<u8, s16, 3>,
         },
         {
-            Pos_ReadIndex<u8, float, 2>, Pos_ReadIndex<u8, float, 3>,
+            Pos_ReadIndex<u8, float, 2>,
+            Pos_ReadIndex<u8, float, 3>,
         },
     },
     {
         {
-            Pos_ReadIndex<u16, u8, 2>, Pos_ReadIndex<u16, u8, 3>,
+            Pos_ReadIndex<u16, u8, 2>,
+            Pos_ReadIndex<u16, u8, 3>,
         },
         {
-            Pos_ReadIndex<u16, s8, 2>, Pos_ReadIndex<u16, s8, 3>,
+            Pos_ReadIndex<u16, s8, 2>,
+            Pos_ReadIndex<u16, s8, 3>,
         },
         {
-            Pos_ReadIndex<u16, u16, 2>, Pos_ReadIndex<u16, u16, 3>,
+            Pos_ReadIndex<u16, u16, 2>,
+            Pos_ReadIndex<u16, u16, 3>,
         },
         {
-            Pos_ReadIndex<u16, s16, 2>, Pos_ReadIndex<u16, s16, 3>,
+            Pos_ReadIndex<u16, s16, 2>,
+            Pos_ReadIndex<u16, s16, 3>,
         },
         {
-            Pos_ReadIndex<u16, float, 2>, Pos_ReadIndex<u16, float, 3>,
+            Pos_ReadIndex<u16, float, 2>,
+            Pos_ReadIndex<u16, float, 3>,
         },
     },
 };
@@ -149,70 +169,90 @@ static TPipelineFunction tableReadPosition[4][8][2] = {
 static int tableReadPositionVertexSize[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,
         },
         {
-            2, 3,
+            2,
+            3,
         },
         {
-            4, 6,
+            4,
+            6,
         },
         {
-            4, 6,
+            4,
+            6,
         },
         {
-            8, 12,
+            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,
         },
     },
 };
diff --git a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
index 99d3a797ec..a64e1f1cde 100644
--- a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
@@ -89,70 +89,90 @@ void TexCoord_ReadIndex(VertexLoader* loader)
 static TPipelineFunction tableReadTexCoord[4][8][2] = {
     {
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
         {
-            nullptr, nullptr,
+            nullptr,
+            nullptr,
         },
     },
     {
         {
-            TexCoord_ReadDirect<u8, 1>, TexCoord_ReadDirect<u8, 2>,
+            TexCoord_ReadDirect<u8, 1>,
+            TexCoord_ReadDirect<u8, 2>,
         },
         {
-            TexCoord_ReadDirect<s8, 1>, TexCoord_ReadDirect<s8, 2>,
+            TexCoord_ReadDirect<s8, 1>,
+            TexCoord_ReadDirect<s8, 2>,
         },
         {
-            TexCoord_ReadDirect<u16, 1>, TexCoord_ReadDirect<u16, 2>,
+            TexCoord_ReadDirect<u16, 1>,
+            TexCoord_ReadDirect<u16, 2>,
         },
         {
-            TexCoord_ReadDirect<s16, 1>, TexCoord_ReadDirect<s16, 2>,
+            TexCoord_ReadDirect<s16, 1>,
+            TexCoord_ReadDirect<s16, 2>,
         },
         {
-            TexCoord_ReadDirect<float, 1>, TexCoord_ReadDirect<float, 2>,
+            TexCoord_ReadDirect<float, 1>,
+            TexCoord_ReadDirect<float, 2>,
         },
     },
     {
         {
-            TexCoord_ReadIndex<u8, u8, 1>, TexCoord_ReadIndex<u8, u8, 2>,
+            TexCoord_ReadIndex<u8, u8, 1>,
+            TexCoord_ReadIndex<u8, u8, 2>,
         },
         {
-            TexCoord_ReadIndex<u8, s8, 1>, TexCoord_ReadIndex<u8, s8, 2>,
+            TexCoord_ReadIndex<u8, s8, 1>,
+            TexCoord_ReadIndex<u8, s8, 2>,
         },
         {
-            TexCoord_ReadIndex<u8, u16, 1>, TexCoord_ReadIndex<u8, u16, 2>,
+            TexCoord_ReadIndex<u8, u16, 1>,
+            TexCoord_ReadIndex<u8, u16, 2>,
         },
         {
-            TexCoord_ReadIndex<u8, s16, 1>, TexCoord_ReadIndex<u8, s16, 2>,
+            TexCoord_ReadIndex<u8, s16, 1>,
+            TexCoord_ReadIndex<u8, s16, 2>,
         },
         {
-            TexCoord_ReadIndex<u8, float, 1>, TexCoord_ReadIndex<u8, float, 2>,
+            TexCoord_ReadIndex<u8, float, 1>,
+            TexCoord_ReadIndex<u8, float, 2>,
         },
     },
     {
         {
-            TexCoord_ReadIndex<u16, u8, 1>, TexCoord_ReadIndex<u16, u8, 2>,
+            TexCoord_ReadIndex<u16, u8, 1>,
+            TexCoord_ReadIndex<u16, u8, 2>,
         },
         {
-            TexCoord_ReadIndex<u16, s8, 1>, TexCoord_ReadIndex<u16, s8, 2>,
+            TexCoord_ReadIndex<u16, s8, 1>,
+            TexCoord_ReadIndex<u16, s8, 2>,
         },
         {
-            TexCoord_ReadIndex<u16, u16, 1>, TexCoord_ReadIndex<u16, u16, 2>,
+            TexCoord_ReadIndex<u16, u16, 1>,
+            TexCoord_ReadIndex<u16, u16, 2>,
         },
         {
-            TexCoord_ReadIndex<u16, s16, 1>, TexCoord_ReadIndex<u16, s16, 2>,
+            TexCoord_ReadIndex<u16, s16, 1>,
+            TexCoord_ReadIndex<u16, s16, 2>,
         },
         {
-            TexCoord_ReadIndex<u16, float, 1>, TexCoord_ReadIndex<u16, float, 2>,
+            TexCoord_ReadIndex<u16, float, 1>,
+            TexCoord_ReadIndex<u16, float, 2>,
         },
     },
 };
@@ -160,70 +180,90 @@ static TPipelineFunction tableReadTexCoord[4][8][2] = {
 static int tableReadTexCoordVertexSize[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,
         },
         {
-            1, 2,
+            1,
+            2,
         },
         {
-            2, 4,
+            2,
+            4,
         },
         {
-            2, 4,
+            2,
+            4,
         },
         {
-            4, 8,
+            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,
         },
     },
 };