Merge pull request #8532 from lioncash/shader-common-fmt

VideoCommon/ShaderGenCommon: Convert helper functions over to fmt where applicable

Source/Core/VideoBackends/D3D/DXPipeline.cpp

@@ -2,9 +2,6 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <cstring>
-
 #include "Common/Assert.h"
 #include "Common/Logging/Log.h"
 
@@ -15,6 +12,7 @@
 #include "VideoBackends/D3D/DXTexture.h"
 #include "VideoBackends/D3D/Render.h"
 #include "VideoBackends/D3D/VertexManager.h"
+#include "VideoCommon/VideoConfig.h"
 
 namespace DX11
 {

Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp

@@ -33,6 +33,7 @@
 #include "VideoCommon/VertexLoaderManager.h"
 #include "VideoCommon/VertexShaderManager.h"
 #include "VideoCommon/VideoBackendBase.h"
+#include "VideoCommon/VideoConfig.h"
 
 namespace OGL
 {

Source/Core/VideoBackends/OGL/Render.cpp

@@ -10,10 +10,7 @@
 #include <cstdio>
 #include <memory>
 #include <string>
-#include <tuple>
-#include <vector>
 
-#include "Common/Assert.h"
 #include "Common/Atomic.h"
 #include "Common/CommonTypes.h"
 #include "Common/GL/GLContext.h"
@@ -24,30 +21,23 @@
 #include "Common/StringUtil.h"
 
 #include "Core/Config/GraphicsSettings.h"
-#include "Core/Core.h"
 
 #include "VideoBackends/OGL/BoundingBox.h"
 #include "VideoBackends/OGL/OGLPipeline.h"
 #include "VideoBackends/OGL/OGLShader.h"
 #include "VideoBackends/OGL/OGLTexture.h"
 #include "VideoBackends/OGL/ProgramShaderCache.h"
 #include "VideoBackends/OGL/SamplerCache.h"
-#include "VideoBackends/OGL/StreamBuffer.h"
 #include "VideoBackends/OGL/VertexManager.h"
 
 #include "VideoCommon/BPFunctions.h"
 #include "VideoCommon/DriverDetails.h"
 #include "VideoCommon/FramebufferManager.h"
-#include "VideoCommon/IndexGenerator.h"
 #include "VideoCommon/OnScreenDisplay.h"
-#include "VideoCommon/PixelEngine.h"
 #include "VideoCommon/PostProcessing.h"
 #include "VideoCommon/RenderState.h"
-#include "VideoCommon/ShaderGenCommon.h"
-#include "VideoCommon/VertexShaderManager.h"
-#include "VideoCommon/VideoBackendBase.h"
+#include "VideoCommon/VideoCommon.h"
 #include "VideoCommon/VideoConfig.h"
-#include "VideoCommon/XFMemory.h"
 
 namespace OGL
 {

Source/Core/VideoBackends/OGL/main.cpp

@@ -55,6 +55,7 @@ Make AA apply instantly during gameplay if possible
 
 #include "VideoCommon/FramebufferManager.h"
 #include "VideoCommon/TextureCacheBase.h"
+#include "VideoCommon/VideoCommon.h"
 #include "VideoCommon/VideoConfig.h"
 
 namespace OGL

Source/Core/VideoBackends/Vulkan/ObjectCache.cpp

@@ -21,7 +21,7 @@
 #include "VideoBackends/Vulkan/VKTexture.h"
 #include "VideoBackends/Vulkan/VertexFormat.h"
 #include "VideoBackends/Vulkan/VulkanContext.h"
-#include "VideoCommon/Statistics.h"
+#include "VideoCommon/VideoCommon.h"
 
 namespace Vulkan
 {

Source/Core/VideoCommon/FramebufferManager.cpp

@@ -3,9 +3,8 @@
 // Refer to the license.txt file included.
 
 #include "VideoCommon/FramebufferManager.h"
+
 #include <memory>
-#include "VideoCommon/FramebufferShaderGen.h"
-#include "VideoCommon/VertexManagerBase.h"
 
 #include "Common/ChunkFile.h"
 #include "Common/Logging/Log.h"
@@ -17,7 +16,10 @@
 #include "VideoCommon/AbstractStagingTexture.h"
 #include "VideoCommon/AbstractTexture.h"
 #include "VideoCommon/DriverDetails.h"
+#include "VideoCommon/FramebufferShaderGen.h"
 #include "VideoCommon/RenderBase.h"
+#include "VideoCommon/VertexManagerBase.h"
+#include "VideoCommon/VideoCommon.h"
 #include "VideoCommon/VideoConfig.h"
 
 // Maximum number of pixels poked in one batch * 6

Source/Core/VideoCommon/FramebufferShaderGen.cpp

@@ -12,6 +12,8 @@
 #include "VideoCommon/FramebufferManager.h"
 #include "VideoCommon/TextureDecoder.h"
 #include "VideoCommon/VertexShaderGen.h"
+#include "VideoCommon/VideoCommon.h"
+#include "VideoCommon/VideoConfig.h"
 
 namespace FramebufferShaderGen
 {

Source/Core/VideoCommon/GeometryShaderGen.cpp

@@ -91,7 +91,7 @@ ShaderCode GenerateGeometryShaderCode(APIType ApiType, const ShaderHostConfig& h
             "};\n");
 
   out.Write("struct VS_OUTPUT {\n");
-  GenerateVSOutputMembers<ShaderCode>(out, ApiType, uid_data->numTexGens, host_config, "");
+  GenerateVSOutputMembers(out, ApiType, uid_data->numTexGens, host_config, "");
   out.Write("};\n");
 
   if (ApiType == APIType::OpenGL || ApiType == APIType::Vulkan)
@@ -100,13 +100,13 @@ ShaderCode GenerateGeometryShaderCode(APIType ApiType, const ShaderHostConfig& h
       out.Write("#define InstanceID gl_InvocationID\n");
 
     out.Write("VARYING_LOCATION(0) in VertexData {\n");
-    GenerateVSOutputMembers<ShaderCode>(out, ApiType, uid_data->numTexGens, host_config,
-                                        GetInterpolationQualifier(msaa, ssaa, true, true));
+    GenerateVSOutputMembers(out, ApiType, uid_data->numTexGens, host_config,
+                            GetInterpolationQualifier(msaa, ssaa, true, true));
     out.Write("} vs[%d];\n", vertex_in);
 
     out.Write("VARYING_LOCATION(0) out VertexData {\n");
-    GenerateVSOutputMembers<ShaderCode>(out, ApiType, uid_data->numTexGens, host_config,
-                                        GetInterpolationQualifier(msaa, ssaa, true, false));
+    GenerateVSOutputMembers(out, ApiType, uid_data->numTexGens, host_config,
+                            GetInterpolationQualifier(msaa, ssaa, true, false));
 
     if (stereo)
       out.Write("\tflat int layer;\n");

Source/Core/VideoCommon/PostProcessing.cpp

@@ -28,6 +28,7 @@
 #include "VideoCommon/RenderBase.h"
 #include "VideoCommon/ShaderCache.h"
 #include "VideoCommon/VertexManagerBase.h"
+#include "VideoCommon/VideoCommon.h"
 #include "VideoCommon/VideoConfig.h"
 
 namespace VideoCommon

Source/Core/VideoCommon/ShaderCache.cpp

@@ -15,14 +15,19 @@
 #include "VideoCommon/Statistics.h"
 #include "VideoCommon/VertexLoaderManager.h"
 #include "VideoCommon/VertexManagerBase.h"
+#include "VideoCommon/VideoCommon.h"
+#include "VideoCommon/VideoConfig.h"
 
-#include "imgui.h"
+#include <imgui.h>
 
 std::unique_ptr<VideoCommon::ShaderCache> g_shader_cache;
 
 namespace VideoCommon
 {
-ShaderCache::ShaderCache() = default;
+ShaderCache::ShaderCache() : m_api_type{APIType::Nothing}
+{
+}
+
 ShaderCache::~ShaderCache()
 {
   ClearCaches();

Source/Core/VideoCommon/ShaderCache.h

@@ -34,6 +34,7 @@
 
 class NativeVertexFormat;
 enum class AbstractTextureFormat : u32;
+enum class APIType;
 enum class TextureFormat;
 enum class TLUTFormat;
 
@@ -191,7 +192,7 @@ class ShaderCache final
   };
 
   // Configuration bits.
-  APIType m_api_type = APIType::Nothing;
+  APIType m_api_type;
   ShaderHostConfig m_host_config = {};
   std::unique_ptr<AsyncShaderCompiler> m_async_shader_compiler;
 

Source/Core/VideoCommon/ShaderGenCommon.cpp

@@ -8,6 +8,8 @@
 
 #include "Common/FileUtil.h"
 #include "Core/ConfigManager.h"
+#include "VideoCommon/VideoCommon.h"
+#include "VideoCommon/VideoConfig.h"
 
 ShaderHostConfig ShaderHostConfig::GetCurrent()
 {
@@ -84,3 +86,100 @@ std::string GetDiskShaderCacheFileName(APIType api_type, const char* type, bool
   filename += ".cache";
   return filename;
 }
+
+static void DefineOutputMember(ShaderCode& object, APIType api_type, std::string_view qualifier,
+                               std::string_view type, std::string_view name, int var_index,
+                               std::string_view semantic = {}, int semantic_index = -1)
+{
+  object.WriteFmt("\t{} {} {}", qualifier, type, name);
+
+  if (var_index != -1)
+    object.WriteFmt("{}", var_index);
+
+  if (api_type == APIType::D3D && !semantic.empty())
+  {
+    if (semantic_index != -1)
+      object.WriteFmt(" : {}{}", semantic, semantic_index);
+    else
+      object.WriteFmt(" : {}", semantic);
+  }
+
+  object.WriteFmt(";\n");
+}
+
+void GenerateVSOutputMembers(ShaderCode& object, APIType api_type, u32 texgens,
+                             const ShaderHostConfig& host_config, std::string_view qualifier)
+{
+  DefineOutputMember(object, api_type, qualifier, "float4", "pos", -1, "SV_Position");
+  DefineOutputMember(object, api_type, qualifier, "float4", "colors_", 0, "COLOR", 0);
+  DefineOutputMember(object, api_type, qualifier, "float4", "colors_", 1, "COLOR", 1);
+
+  for (unsigned int i = 0; i < texgens; ++i)
+    DefineOutputMember(object, api_type, qualifier, "float3", "tex", i, "TEXCOORD", i);
+
+  if (!host_config.fast_depth_calc)
+    DefineOutputMember(object, api_type, qualifier, "float4", "clipPos", -1, "TEXCOORD", texgens);
+
+  if (host_config.per_pixel_lighting)
+  {
+    DefineOutputMember(object, api_type, qualifier, "float3", "Normal", -1, "TEXCOORD",
+                       texgens + 1);
+    DefineOutputMember(object, api_type, qualifier, "float3", "WorldPos", -1, "TEXCOORD",
+                       texgens + 2);
+  }
+
+  if (host_config.backend_geometry_shaders)
+  {
+    DefineOutputMember(object, api_type, qualifier, "float", "clipDist", 0, "SV_ClipDistance", 0);
+    DefineOutputMember(object, api_type, qualifier, "float", "clipDist", 1, "SV_ClipDistance", 1);
+  }
+}
+
+void AssignVSOutputMembers(ShaderCode& object, std::string_view a, std::string_view b, u32 texgens,
+                           const ShaderHostConfig& host_config)
+{
+  object.WriteFmt("\t{}.pos = {}.pos;\n", a, b);
+  object.WriteFmt("\t{}.colors_0 = {}.colors_0;\n", a, b);
+  object.WriteFmt("\t{}.colors_1 = {}.colors_1;\n", a, b);
+
+  for (unsigned int i = 0; i < texgens; ++i)
+    object.WriteFmt("\t{}.tex{} = {}.tex{};\n", a, i, b, i);
+
+  if (!host_config.fast_depth_calc)
+    object.WriteFmt("\t{}.clipPos = {}.clipPos;\n", a, b);
+
+  if (host_config.per_pixel_lighting)
+  {
+    object.WriteFmt("\t{}.Normal = {}.Normal;\n", a, b);
+    object.WriteFmt("\t{}.WorldPos = {}.WorldPos;\n", a, b);
+  }
+
+  if (host_config.backend_geometry_shaders)
+  {
+    object.WriteFmt("\t{}.clipDist0 = {}.clipDist0;\n", a, b);
+    object.WriteFmt("\t{}.clipDist1 = {}.clipDist1;\n", a, b);
+  }
+}
+
+const char* GetInterpolationQualifier(bool msaa, bool ssaa, bool in_glsl_interface_block, bool in)
+{
+  if (!msaa)
+    return "";
+
+  // Without GL_ARB_shading_language_420pack support, the interpolation qualifier must be
+  // "centroid in" and not "centroid", even within an interface block.
+  if (in_glsl_interface_block && !g_ActiveConfig.backend_info.bSupportsBindingLayout)
+  {
+    if (!ssaa)
+      return in ? "centroid in" : "centroid out";
+    else
+      return in ? "sample in" : "sample out";
+  }
+  else
+  {
+    if (!ssaa)
+      return "centroid";
+    else
+      return "sample";
+  }
+}