1 files changed, 32 insertions, 39 deletions

diff --git a/src/video_core/renderer_opengl/gl_shader_gen.cpp b/src/video_core/renderer_opengl/gl_shader_gen.cpp
index 0e22eede9..34946fb47 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_gen.cpp
@@ -2,8 +2,13 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <string>
+
 #include <fmt/format.h>
+
 #include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/shader_type.h"
+#include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
 #include "video_core/shader/shader_ir.h"
@@ -11,6 +16,7 @@
 namespace OpenGL::GLShader {
 
 using Tegra::Engines::Maxwell3D;
+using Tegra::Engines::ShaderType;
 using VideoCommon::Shader::CompileDepth;
 using VideoCommon::Shader::CompilerSettings;
 using VideoCommon::Shader::ProgramCode;
@@ -18,53 +24,40 @@ using VideoCommon::Shader::ShaderIR;
 
 std::string GenerateVertexShader(const Device& device, const ShaderIR& ir, const ShaderIR* ir_b) {
     std::string out = GetCommonDeclarations();
-    out += R"(
-layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
-    vec4 viewport_flip;
-    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-};
-
-)";
-    const auto stage = ir_b ? ProgramType::VertexA : ProgramType::VertexB;
-    out += Decompile(device, ir, stage, "vertex");
+    out += fmt::format(R"(
+layout (std140, binding = {}) uniform vs_config {{
+    float y_direction;
+}};
+
+)",
+                       EmulationUniformBlockBinding);
+    out += Decompile(device, ir, ShaderType::Vertex, "vertex");
     if (ir_b) {
-        out += Decompile(device, *ir_b, ProgramType::VertexB, "vertex_b");
+        out += Decompile(device, *ir_b, ShaderType::Vertex, "vertex_b");
     }
 
     out += R"(
 void main() {
+    gl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);
     execute_vertex();
 )";
-
     if (ir_b) {
         out += "    execute_vertex_b();";
     }
-
-    out += R"(
-
-    // Set Position Y direction
-    gl_Position.y *= utof(config_pack[2]);
-    // Check if the flip stage is VertexB
-    // Config pack's second value is flip_stage
-    if (config_pack[1] == 1) {
-        // Viewport can be flipped, which is unsupported by glViewport
-        gl_Position.xy *= viewport_flip.xy;
-    }
-}
-)";
+    out += "}\n";
     return out;
 }
 
 std::string GenerateGeometryShader(const Device& device, const ShaderIR& ir) {
     std::string out = GetCommonDeclarations();
-    out += R"(
-layout (std140, binding = EMULATION_UBO_BINDING) uniform gs_config {
-    vec4 viewport_flip;
-    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-};
+    out += fmt::format(R"(
+layout (std140, binding = {}) uniform gs_config {{
+    float y_direction;
+}};
 
-)";
-    out += Decompile(device, ir, ProgramType::Geometry, "geometry");
+)",
+                       EmulationUniformBlockBinding);
+    out += Decompile(device, ir, ShaderType::Geometry, "geometry");
 
     out += R"(
 void main() {
@@ -76,7 +69,7 @@ void main() {
 
 std::string GenerateFragmentShader(const Device& device, const ShaderIR& ir) {
     std::string out = GetCommonDeclarations();
-    out += R"(
+    out += fmt::format(R"(
 layout (location = 0) out vec4 FragColor0;
 layout (location = 1) out vec4 FragColor1;
 layout (location = 2) out vec4 FragColor2;
@@ -86,13 +79,13 @@ layout (location = 5) out vec4 FragColor5;
 layout (location = 6) out vec4 FragColor6;
 layout (location = 7) out vec4 FragColor7;
 
-layout (std140, binding = EMULATION_UBO_BINDING) uniform fs_config {
-    vec4 viewport_flip;
-    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-};
+layout (std140, binding = {}) uniform fs_config {{
+    float y_direction;
+}};
 
-)";
-    out += Decompile(device, ir, ProgramType::Fragment, "fragment");
+)",
+                       EmulationUniformBlockBinding);
+    out += Decompile(device, ir, ShaderType::Fragment, "fragment");
 
     out += R"(
 void main() {
@@ -104,7 +97,7 @@ void main() {
 
 std::string GenerateComputeShader(const Device& device, const ShaderIR& ir) {
     std::string out = GetCommonDeclarations();
-    out += Decompile(device, ir, ProgramType::Compute, "compute");
+    out += Decompile(device, ir, ShaderType::Compute, "compute");
     out += R"(
 void main() {
     execute_compute();