Merge pull request #11388 from AdmiralCurtiss/globals-vertexshaderman…

…ager

VideoCommon: De-globalize VertexShaderManager class.

Source/Core/Core/Boot/Boot_BS2Emu.cpp

@@ -256,6 +256,8 @@ bool CBoot::EmulatedBS2_GC(const DiscIO::VolumeDisc& volume,
 {
   INFO_LOG_FMT(BOOT, "Faking GC BS2...");
 
+  auto& system = Core::System::GetInstance();
+
   SetupMSR();
   SetupHID(/*is_wii*/ false);
   SetupBAT(/*is_wii*/ false);
@@ -271,11 +273,11 @@ bool CBoot::EmulatedBS2_GC(const DiscIO::VolumeDisc& volume,
   xfmem.postMatrices[0x3e * 4 + 1] = 1.0f;
   xfmem.postMatrices[0x3f * 4 + 2] = 1.0f;
   g_vertex_manager->Flush();
-  VertexShaderManager::InvalidateXFRange(XFMEM_POSTMATRICES + 0x3d * 4, XFMEM_POSTMATRICES_END);
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
+  vertex_shader_manager.InvalidateXFRange(XFMEM_POSTMATRICES + 0x3d * 4, XFMEM_POSTMATRICES_END);
 
   DVDReadDiscID(volume, 0x00000000);
 
-  auto& system = Core::System::GetInstance();
   auto& memory = system.GetMemory();
   bool streaming = memory.Read_U8(0x80000008);
   if (streaming)

Source/Core/Core/System.cpp

@@ -22,6 +22,7 @@
 #include "VideoCommon/Fifo.h"
 #include "VideoCommon/PixelEngine.h"
 #include "VideoCommon/PixelShaderManager.h"
+#include "VideoCommon/VertexShaderManager.h"
 
 namespace Core
 {
@@ -45,6 +46,7 @@ struct System::Impl
   PixelShaderManager m_pixel_shader_manager;
   SerialInterface::SerialInterfaceState m_serial_interface_state;
   Sram m_sram;
+  VertexShaderManager m_vertex_shader_manager;
   VideoInterface::VideoInterfaceState m_video_interface_state;
 };
 
@@ -161,6 +163,11 @@ Sram& System::GetSRAM() const
   return m_impl->m_sram;
 }
 
+VertexShaderManager& System::GetVertexShaderManager() const
+{
+  return m_impl->m_vertex_shader_manager;
+}
+
 VideoInterface::VideoInterfaceState& System::GetVideoInterfaceState() const
 {
   return m_impl->m_video_interface_state;

Source/Core/Core/System.h

@@ -8,6 +8,7 @@
 class PixelShaderManager;
 class SoundStream;
 struct Sram;
+class VertexShaderManager;
 
 namespace AudioInterface
 {
@@ -110,6 +111,7 @@ class System
   PixelShaderManager& GetPixelShaderManager() const;
   SerialInterface::SerialInterfaceState& GetSerialInterfaceState() const;
   Sram& GetSRAM() const;
+  VertexShaderManager& GetVertexShaderManager() const;
   VideoInterface::VideoInterfaceState& GetVideoInterfaceState() const;
 
 private:

Source/Core/VideoBackends/D3D/D3DVertexManager.cpp

@@ -264,12 +264,14 @@ void VertexManager::UploadUniforms()
 {
   auto& system = Core::System::GetInstance();
 
-  if (VertexShaderManager::dirty)
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
+  if (vertex_shader_manager.dirty)
   {
-    UpdateConstantBuffer(m_vertex_constant_buffer.Get(), &VertexShaderManager::constants,
+    UpdateConstantBuffer(m_vertex_constant_buffer.Get(), &vertex_shader_manager.constants,
                          sizeof(VertexShaderConstants));
-    VertexShaderManager::dirty = false;
+    vertex_shader_manager.dirty = false;
   }
+
   if (GeometryShaderManager::dirty)
   {
     UpdateConstantBuffer(m_geometry_constant_buffer.Get(), &GeometryShaderManager::constants,

Source/Core/VideoBackends/D3D12/D3D12VertexManager.cpp

@@ -145,15 +145,18 @@ void VertexManager::UploadUniforms()
 
 void VertexManager::UpdateVertexShaderConstants()
 {
-  if (!VertexShaderManager::dirty || !ReserveConstantStorage())
+  auto& system = Core::System::GetInstance();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
+
+  if (!vertex_shader_manager.dirty || !ReserveConstantStorage())
     return;
 
   Renderer::GetInstance()->SetConstantBuffer(1, m_uniform_stream_buffer.GetCurrentGPUPointer());
-  std::memcpy(m_uniform_stream_buffer.GetCurrentHostPointer(), &VertexShaderManager::constants,
+  std::memcpy(m_uniform_stream_buffer.GetCurrentHostPointer(), &vertex_shader_manager.constants,
               sizeof(VertexShaderConstants));
   m_uniform_stream_buffer.CommitMemory(sizeof(VertexShaderConstants));
   ADDSTAT(g_stats.this_frame.bytes_uniform_streamed, sizeof(VertexShaderConstants));
-  VertexShaderManager::dirty = false;
+  vertex_shader_manager.dirty = false;
 }
 
 void VertexManager::UpdateGeometryShaderConstants()
@@ -237,12 +240,13 @@ void VertexManager::UploadAllConstants()
 
   auto& system = Core::System::GetInstance();
   auto& pixel_shader_manager = system.GetPixelShaderManager();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
 
   // Copy the actual data in
   std::memcpy(m_uniform_stream_buffer.GetCurrentHostPointer() + pixel_constants_offset,
               &pixel_shader_manager.constants, sizeof(PixelShaderConstants));
   std::memcpy(m_uniform_stream_buffer.GetCurrentHostPointer() + vertex_constants_offset,
-              &VertexShaderManager::constants, sizeof(VertexShaderConstants));
+              &vertex_shader_manager.constants, sizeof(VertexShaderConstants));
   std::memcpy(m_uniform_stream_buffer.GetCurrentHostPointer() + geometry_constants_offset,
               &GeometryShaderManager::constants, sizeof(GeometryShaderConstants));
 
@@ -251,7 +255,7 @@ void VertexManager::UploadAllConstants()
   ADDSTAT(g_stats.this_frame.bytes_uniform_streamed, allocation_size);
 
   // Clear dirty flags
-  VertexShaderManager::dirty = false;
+  vertex_shader_manager.dirty = false;
   GeometryShaderManager::dirty = false;
   pixel_shader_manager.dirty = false;
 }

Source/Core/VideoBackends/Metal/MTLStateTracker.mm

@@ -836,7 +836,9 @@ static NSRange RangeOfBits(u32 value)
     {
       m_flags.has_gx_vs_uniform = true;
       Map map = Allocate(UploadBuffer::Uniform, sizeof(VertexShaderConstants), AlignMask::Uniform);
-      memcpy(map.cpu_buffer, &VertexShaderManager::constants, sizeof(VertexShaderConstants));
+      auto& system = Core::System::GetInstance();
+      auto& vertex_shader_manager = system.GetVertexShaderManager();
+      memcpy(map.cpu_buffer, &vertex_shader_manager.constants, sizeof(VertexShaderConstants));
       SetVertexBufferNow(1, map.gpu_buffer, map.gpu_offset);
       if (pipe->UsesFragmentBuffer(1))
         SetFragmentBufferNow(1, map.gpu_buffer, map.gpu_offset);

Source/Core/VideoBackends/Metal/MTLVertexManager.mm

@@ -93,9 +93,10 @@
 {
   auto& system = Core::System::GetInstance();
   auto& pixel_shader_manager = system.GetPixelShaderManager();
-  g_state_tracker->InvalidateUniforms(VertexShaderManager::dirty, GeometryShaderManager::dirty,
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
+  g_state_tracker->InvalidateUniforms(vertex_shader_manager.dirty, GeometryShaderManager::dirty,
                                       pixel_shader_manager.dirty);
-  VertexShaderManager::dirty = false;
+  vertex_shader_manager.dirty = false;
   GeometryShaderManager::dirty = false;
   pixel_shader_manager.dirty = false;
 }

Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp

@@ -223,14 +223,15 @@ void ProgramShaderCache::UploadConstants()
 {
   auto& system = Core::System::GetInstance();
   auto& pixel_shader_manager = system.GetPixelShaderManager();
-  if (pixel_shader_manager.dirty || VertexShaderManager::dirty || GeometryShaderManager::dirty)
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
+  if (pixel_shader_manager.dirty || vertex_shader_manager.dirty || GeometryShaderManager::dirty)
   {
     auto buffer = s_buffer->Map(s_ubo_buffer_size, s_ubo_align);
 
     memcpy(buffer.first, &pixel_shader_manager.constants, sizeof(PixelShaderConstants));
 
     memcpy(buffer.first + Common::AlignUp(sizeof(PixelShaderConstants), s_ubo_align),
-           &VertexShaderManager::constants, sizeof(VertexShaderConstants));
+           &vertex_shader_manager.constants, sizeof(VertexShaderConstants));
 
     memcpy(buffer.first + Common::AlignUp(sizeof(PixelShaderConstants), s_ubo_align) +
                Common::AlignUp(sizeof(VertexShaderConstants), s_ubo_align),
@@ -248,7 +249,7 @@ void ProgramShaderCache::UploadConstants()
                       sizeof(GeometryShaderConstants));
 
     pixel_shader_manager.dirty = false;
-    VertexShaderManager::dirty = false;
+    vertex_shader_manager.dirty = false;
     GeometryShaderManager::dirty = false;
 
     ADDSTAT(g_stats.this_frame.bytes_uniform_streamed, s_ubo_buffer_size);

Source/Core/VideoBackends/Software/SWVertexLoader.cpp

@@ -10,6 +10,8 @@
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
 
+#include "Core/System.h"
+
 #include "VideoBackends/Software/NativeVertexFormat.h"
 #include "VideoBackends/Software/Rasterizer.h"
 #include "VideoBackends/Software/SWRenderer.h"
@@ -205,15 +207,19 @@ void SWVertexLoader::ParseVertex(const PortableVertexDeclaration& vdec, int inde
   }
   if (!vdec.normals[1].enable)
   {
-    m_vertex.normal[1][0] = VertexShaderManager::constants.cached_tangent[0];
-    m_vertex.normal[1][1] = VertexShaderManager::constants.cached_tangent[1];
-    m_vertex.normal[1][2] = VertexShaderManager::constants.cached_tangent[2];
+    auto& system = Core::System::GetInstance();
+    auto& vertex_shader_manager = system.GetVertexShaderManager();
+    m_vertex.normal[1][0] = vertex_shader_manager.constants.cached_tangent[0];
+    m_vertex.normal[1][1] = vertex_shader_manager.constants.cached_tangent[1];
+    m_vertex.normal[1][2] = vertex_shader_manager.constants.cached_tangent[2];
   }
   if (!vdec.normals[2].enable)
   {
-    m_vertex.normal[2][0] = VertexShaderManager::constants.cached_binormal[0];
-    m_vertex.normal[2][1] = VertexShaderManager::constants.cached_binormal[1];
-    m_vertex.normal[2][2] = VertexShaderManager::constants.cached_binormal[2];
+    auto& system = Core::System::GetInstance();
+    auto& vertex_shader_manager = system.GetVertexShaderManager();
+    m_vertex.normal[2][0] = vertex_shader_manager.constants.cached_binormal[0];
+    m_vertex.normal[2][1] = vertex_shader_manager.constants.cached_binormal[1];
+    m_vertex.normal[2][2] = vertex_shader_manager.constants.cached_binormal[2];
   }
 
   ParseColorAttributes(&m_vertex, src, vdec);

Source/Core/VideoBackends/Vulkan/VKVertexManager.cpp

@@ -204,17 +204,20 @@ void VertexManager::UploadUniforms()
 
 void VertexManager::UpdateVertexShaderConstants()
 {
-  if (!VertexShaderManager::dirty || !ReserveConstantStorage())
+  auto& system = Core::System::GetInstance();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
+
+  if (!vertex_shader_manager.dirty || !ReserveConstantStorage())
     return;
 
   StateTracker::GetInstance()->SetGXUniformBuffer(
       UBO_DESCRIPTOR_SET_BINDING_VS, m_uniform_stream_buffer->GetBuffer(),
       m_uniform_stream_buffer->GetCurrentOffset(), sizeof(VertexShaderConstants));
-  std::memcpy(m_uniform_stream_buffer->GetCurrentHostPointer(), &VertexShaderManager::constants,
+  std::memcpy(m_uniform_stream_buffer->GetCurrentHostPointer(), &vertex_shader_manager.constants,
               sizeof(VertexShaderConstants));
   m_uniform_stream_buffer->CommitMemory(sizeof(VertexShaderConstants));
   ADDSTAT(g_stats.this_frame.bytes_uniform_streamed, sizeof(VertexShaderConstants));
-  VertexShaderManager::dirty = false;
+  vertex_shader_manager.dirty = false;
 }
 
 void VertexManager::UpdateGeometryShaderConstants()
@@ -289,6 +292,7 @@ void VertexManager::UploadAllConstants()
 
   auto& system = Core::System::GetInstance();
   auto& pixel_shader_manager = system.GetPixelShaderManager();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
 
   // Update bindings
   StateTracker::GetInstance()->SetGXUniformBuffer(
@@ -308,7 +312,7 @@ void VertexManager::UploadAllConstants()
   std::memcpy(m_uniform_stream_buffer->GetCurrentHostPointer() + pixel_constants_offset,
               &pixel_shader_manager.constants, sizeof(PixelShaderConstants));
   std::memcpy(m_uniform_stream_buffer->GetCurrentHostPointer() + vertex_constants_offset,
-              &VertexShaderManager::constants, sizeof(VertexShaderConstants));
+              &vertex_shader_manager.constants, sizeof(VertexShaderConstants));
   std::memcpy(m_uniform_stream_buffer->GetCurrentHostPointer() + geometry_constants_offset,
               &GeometryShaderManager::constants, sizeof(GeometryShaderConstants));
 
@@ -317,7 +321,7 @@ void VertexManager::UploadAllConstants()
   ADDSTAT(g_stats.this_frame.bytes_uniform_streamed, allocation_size);
 
   // Clear dirty flags
-  VertexShaderManager::dirty = false;
+  vertex_shader_manager.dirty = false;
   GeometryShaderManager::dirty = false;
   pixel_shader_manager.dirty = false;
 }

Source/Core/VideoCommon/BPStructs.cpp

@@ -54,7 +54,8 @@ void BPInit()
   bpmem.bpMask = 0xFFFFFF;
 }
 
-static void BPWritten(PixelShaderManager& pixel_shader_manager, const BPCmd& bp,
+static void BPWritten(PixelShaderManager& pixel_shader_manager,
+                      VertexShaderManager& vertex_shader_manager, const BPCmd& bp,
                       int cycles_into_future)
 {
   /*
@@ -136,7 +137,7 @@ static void BPWritten(PixelShaderManager& pixel_shader_manager, const BPCmd& bp,
   case BPMEM_SCISSORTL:      // Scissor Rectable Top, Left
   case BPMEM_SCISSORBR:      // Scissor Rectable Bottom, Right
   case BPMEM_SCISSOROFFSET:  // Scissor Offset
-    VertexShaderManager::SetViewportChanged();
+    vertex_shader_manager.SetViewportChanged();
     GeometryShaderManager::SetViewportChanged();
     return;
   case BPMEM_LINEPTWIDTH:  // Line Width
@@ -762,7 +763,8 @@ void LoadBPReg(u8 reg, u32 value, int cycles_into_future)
   if (reg != BPMEM_BP_MASK)
     bpmem.bpMask = 0xFFFFFF;
 
-  BPWritten(system.GetPixelShaderManager(), bp, cycles_into_future);
+  BPWritten(system.GetPixelShaderManager(), system.GetVertexShaderManager(), bp,
+            cycles_into_future);
 }
 
 void LoadBPRegPreprocess(u8 reg, u32 value, int cycles_into_future)

Source/Core/VideoCommon/OpcodeDecoding.cpp

@@ -59,12 +59,14 @@ class RunCallback final : public Callback
       if (sub_command == MATINDEX_A)
       {
         VertexLoaderManager::g_needs_cp_xf_consistency_check = true;
-        VertexShaderManager::SetTexMatrixChangedA(value);
+        auto& system = Core::System::GetInstance();
+        system.GetVertexShaderManager().SetTexMatrixChangedA(value);
       }
       else if (sub_command == MATINDEX_B)
       {
         VertexLoaderManager::g_needs_cp_xf_consistency_check = true;
-        VertexShaderManager::SetTexMatrixChangedB(value);
+        auto& system = Core::System::GetInstance();
+        system.GetVertexShaderManager().SetTexMatrixChangedB(value);
       }
       else if (sub_command == VCD_LO || sub_command == VCD_HI)
       {

Source/Core/VideoCommon/VertexLoaderManager.cpp

@@ -361,8 +361,10 @@ int RunVertices(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int coun
     }
     s_current_vtx_fmt = loader->m_native_vertex_format;
     g_current_components = loader->m_native_components;
-    VertexShaderManager::SetVertexFormat(loader->m_native_components,
-                                         loader->m_native_vertex_format->GetVertexDeclaration());
+    auto& system = Core::System::GetInstance();
+    auto& vertex_shader_manager = system.GetVertexShaderManager();
+    vertex_shader_manager.SetVertexFormat(loader->m_native_components,
+                                          loader->m_native_vertex_format->GetVertexDeclaration());
 
     // if cull mode is CULL_ALL, tell VertexManager to skip triangles and quads.
     // They still need to go through vertex loading, because we need to calculate a zfreeze refrence

Source/Core/VideoCommon/VertexManagerBase.cpp

@@ -319,8 +319,9 @@ void VertexManagerBase::UploadUniforms()
 void VertexManagerBase::InvalidateConstants()
 {
   auto& system = Core::System::GetInstance();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
   auto& pixel_shader_manager = system.GetPixelShaderManager();
-  VertexShaderManager::dirty = true;
+  vertex_shader_manager.dirty = true;
   GeometryShaderManager::dirty = true;
   pixel_shader_manager.dirty = true;
 }
@@ -486,6 +487,7 @@ void VertexManagerBase::Flush()
 
   auto& system = Core::System::GetInstance();
   auto& pixel_shader_manager = system.GetPixelShaderManager();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
 
   CalculateBinormals(VertexLoaderManager::GetCurrentVertexFormat());
   // Calculate ZSlope for zfreeze
@@ -512,7 +514,7 @@ void VertexManagerBase::Flush()
       }
     }
   }
-  VertexShaderManager::SetConstants(texture_names);
+  vertex_shader_manager.SetConstants(texture_names);
   if (!bpmem.genMode.zfreeze)
   {
     // Must be done after VertexShaderManager::SetConstants()
@@ -634,6 +636,8 @@ void VertexManagerBase::CalculateZSlope(NativeVertexFormat* format)
   // Lookup vertices of the last rendered triangle and software-transform them
   // This allows us to determine the depth slope, which will be used if z-freeze
   // is enabled in the following flush.
+  auto& system = Core::System::GetInstance();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
   for (unsigned int i = 0; i < 3; ++i)
   {
     // If this vertex format has per-vertex position matrix IDs, look it up.
@@ -643,8 +647,8 @@ void VertexManagerBase::CalculateZSlope(NativeVertexFormat* format)
     if (vert_decl.position.components == 2)
       VertexLoaderManager::position_cache[2 - i][2] = 0;
 
-    VertexShaderManager::TransformToClipSpace(&VertexLoaderManager::position_cache[2 - i][0],
-                                              &out[i * 4], mtxIdx);
+    vertex_shader_manager.TransformToClipSpace(&VertexLoaderManager::position_cache[2 - i][0],
+                                               &out[i * 4], mtxIdx);
 
     // Transform to Screenspace
     float inv_w = 1.0f / out[3 + i * 4];
@@ -688,15 +692,17 @@ void VertexManagerBase::CalculateBinormals(NativeVertexFormat* format)
   VertexLoaderManager::tangent_cache[3] = 0;
   VertexLoaderManager::binormal_cache[3] = 0;
 
-  if (VertexShaderManager::constants.cached_tangent != VertexLoaderManager::tangent_cache)
+  auto& system = Core::System::GetInstance();
+  auto& vertex_shader_manager = system.GetVertexShaderManager();
+  if (vertex_shader_manager.constants.cached_tangent != VertexLoaderManager::tangent_cache)
   {
-    VertexShaderManager::constants.cached_tangent = VertexLoaderManager::tangent_cache;
-    VertexShaderManager::dirty = true;
+    vertex_shader_manager.constants.cached_tangent = VertexLoaderManager::tangent_cache;
+    vertex_shader_manager.dirty = true;
   }
-  if (VertexShaderManager::constants.cached_binormal != VertexLoaderManager::binormal_cache)
+  if (vertex_shader_manager.constants.cached_binormal != VertexLoaderManager::binormal_cache)
   {
-    VertexShaderManager::constants.cached_binormal = VertexLoaderManager::binormal_cache;
-    VertexShaderManager::dirty = true;
+    vertex_shader_manager.constants.cached_binormal = VertexLoaderManager::binormal_cache;
+    vertex_shader_manager.dirty = true;
   }
 }