1 files changed, 170 insertions, 161 deletions

diff --git a/src/video_core/renderer_opengl/gl_shader_gen.cpp b/src/video_core/renderer_opengl/gl_shader_gen.cpp
index 059f127af..4854c347e 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_gen.cpp
@@ -6,268 +6,313 @@
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
 
+using Pica::Regs;
+using TevStageConfig = Regs::TevStageConfig;
+
 namespace GLShader {
 
-static bool IsPassThroughTevStage(const Pica::Regs::TevStageConfig& stage) {
-    return (stage.color_op == Pica::Regs::TevStageConfig::Operation::Replace &&
-        stage.alpha_op == Pica::Regs::TevStageConfig::Operation::Replace &&
-        stage.color_source1 == Pica::Regs::TevStageConfig::Source::Previous &&
-        stage.alpha_source1 == Pica::Regs::TevStageConfig::Source::Previous &&
-        stage.color_modifier1 == Pica::Regs::TevStageConfig::ColorModifier::SourceColor &&
-        stage.alpha_modifier1 == Pica::Regs::TevStageConfig::AlphaModifier::SourceAlpha &&
-        stage.GetColorMultiplier() == 1 &&
-        stage.GetAlphaMultiplier() == 1);
+static bool IsPassThroughTevStage(const TevStageConfig& stage) {
+    return (stage.color_op             == TevStageConfig::Operation::Replace &&
+            stage.alpha_op             == TevStageConfig::Operation::Replace &&
+            stage.color_source1        == TevStageConfig::Source::Previous &&
+            stage.alpha_source1        == TevStageConfig::Source::Previous &&
+            stage.color_modifier1      == TevStageConfig::ColorModifier::SourceColor &&
+            stage.alpha_modifier1      == TevStageConfig::AlphaModifier::SourceAlpha &&
+            stage.GetColorMultiplier() == 1 &&
+            stage.GetAlphaMultiplier() == 1);
 }
 
-static void AppendSource(std::string& shader, Pica::Regs::TevStageConfig::Source source, const std::string& index_name) {
-    using Source = Pica::Regs::TevStageConfig::Source;
+static void AppendSource(std::string& out, TevStageConfig::Source source,
+        const std::string& index_name) {
+    using Source = TevStageConfig::Source;
     switch (source) {
     case Source::PrimaryColor:
-        shader += "o[2]";
+        out += "o[2]";
         break;
     case Source::PrimaryFragmentColor:
         // HACK: Until we implement fragment lighting, use primary_color
-        shader += "o[2]";
+        out += "o[2]";
         break;
     case Source::SecondaryFragmentColor:
         // HACK: Until we implement fragment lighting, use zero
-        shader += "vec4(0.0, 0.0, 0.0, 0.0)";
+        out += "vec4(0.0, 0.0, 0.0, 0.0)";
         break;
     case Source::Texture0:
-        shader += "texture(tex[0], o[3].xy)";
+        out += "texture(tex[0], o[3].xy)";
         break;
     case Source::Texture1:
-        shader += "texture(tex[1], o[3].zw)";
+        out += "texture(tex[1], o[3].zw)";
         break;
     case Source::Texture2: // TODO: Unverified
-        shader += "texture(tex[2], o[5].zw)";
+        out += "texture(tex[2], o[5].zw)";
         break;
     case Source::PreviousBuffer:
-        shader += "g_combiner_buffer";
+        out += "g_combiner_buffer";
         break;
     case Source::Constant:
-        shader += "const_color[" + index_name + "]";
+        out += "const_color[" + index_name + "]";
         break;
     case Source::Previous:
-        shader += "g_last_tex_env_out";
+        out += "g_last_tex_env_out";
         break;
     default:
-        shader += "vec4(0.0)";
+        out += "vec4(0.0)";
         LOG_CRITICAL(Render_OpenGL, "Unknown source op %u", source);
         break;
     }
 }
 
-static void AppendColorModifier(std::string& shader, Pica::Regs::TevStageConfig::ColorModifier modifier,
-        Pica::Regs::TevStageConfig::Source source, const std::string& index_name) {
-    using ColorModifier = Pica::Regs::TevStageConfig::ColorModifier;
+static void AppendColorModifier(std::string& out, TevStageConfig::ColorModifier modifier,
+        TevStageConfig::Source source, const std::string& index_name) {
+    using ColorModifier = TevStageConfig::ColorModifier;
     switch (modifier) {
     case ColorModifier::SourceColor:
-        AppendSource(shader, source, index_name);
-        shader += ".rgb";
+        AppendSource(out, source, index_name);
+        out += ".rgb";
         break;
     case ColorModifier::OneMinusSourceColor:
-        shader += "vec3(1.0) - ";
-        AppendSource(shader, source, index_name);
-        shader += ".rgb";
+        out += "vec3(1.0) - ";
+        AppendSource(out, source, index_name);
+        out += ".rgb";
         break;
     case ColorModifier::SourceAlpha:
-        AppendSource(shader, source, index_name);
-        shader += ".aaa";
+        AppendSource(out, source, index_name);
+        out += ".aaa";
         break;
     case ColorModifier::OneMinusSourceAlpha:
-        shader += "vec3(1.0) - ";
-        AppendSource(shader, source, index_name);
-        shader += ".aaa";
+        out += "vec3(1.0) - ";
+        AppendSource(out, source, index_name);
+        out += ".aaa";
         break;
     case ColorModifier::SourceRed:
-        AppendSource(shader, source, index_name);
-        shader += ".rrr";
+        AppendSource(out, source, index_name);
+        out += ".rrr";
         break;
     case ColorModifier::OneMinusSourceRed:
-        shader += "vec3(1.0) - ";
-        AppendSource(shader, source, index_name);
-        shader += ".rrr";
+        out += "vec3(1.0) - ";
+        AppendSource(out, source, index_name);
+        out += ".rrr";
         break;
     case ColorModifier::SourceGreen:
-        AppendSource(shader, source, index_name);
-        shader += ".ggg";
+        AppendSource(out, source, index_name);
+        out += ".ggg";
         break;
     case ColorModifier::OneMinusSourceGreen:
-        shader += "vec3(1.0) - ";
-        AppendSource(shader, source, index_name);
-        shader += ".ggg";
+        out += "vec3(1.0) - ";
+        AppendSource(out, source, index_name);
+        out += ".ggg";
         break;
     case ColorModifier::SourceBlue:
-        AppendSource(shader, source, index_name);
-        shader += ".bbb";
+        AppendSource(out, source, index_name);
+        out += ".bbb";
         break;
     case ColorModifier::OneMinusSourceBlue:
-        shader += "vec3(1.0) - ";
-        AppendSource(shader, source, index_name);
-        shader += ".bbb";
+        out += "vec3(1.0) - ";
+        AppendSource(out, source, index_name);
+        out += ".bbb";
         break;
     default:
-        shader += "vec3(0.0)";
+        out += "vec3(0.0)";
         LOG_CRITICAL(Render_OpenGL, "Unknown color modifier op %u", modifier);
         break;
     }
 }
 
-static void AppendAlphaModifier(std::string& shader, Pica::Regs::TevStageConfig::AlphaModifier modifier,
-        Pica::Regs::TevStageConfig::Source source, const std::string& index_name) {
-    using AlphaModifier = Pica::Regs::TevStageConfig::AlphaModifier;
+static void AppendAlphaModifier(std::string& out, TevStageConfig::AlphaModifier modifier,
+        TevStageConfig::Source source, const std::string& index_name) {
+    using AlphaModifier = TevStageConfig::AlphaModifier;
     switch (modifier) {
     case AlphaModifier::SourceAlpha:
-        AppendSource(shader, source, index_name);
-        shader += ".a";
+        AppendSource(out, source, index_name);
+        out += ".a";
         break;
     case AlphaModifier::OneMinusSourceAlpha:
-        shader += "1.0 - ";
-        AppendSource(shader, source, index_name);
-        shader += ".a";
+        out += "1.0 - ";
+        AppendSource(out, source, index_name);
+        out += ".a";
         break;
     case AlphaModifier::SourceRed:
-        AppendSource(shader, source, index_name);
-        shader += ".r";
+        AppendSource(out, source, index_name);
+        out += ".r";
         break;
     case AlphaModifier::OneMinusSourceRed:
-        shader += "1.0 - ";
-        AppendSource(shader, source, index_name);
-        shader += ".r";
+        out += "1.0 - ";
+        AppendSource(out, source, index_name);
+        out += ".r";
         break;
     case AlphaModifier::SourceGreen:
-        AppendSource(shader, source, index_name);
-        shader += ".g";
+        AppendSource(out, source, index_name);
+        out += ".g";
         break;
     case AlphaModifier::OneMinusSourceGreen:
-        shader += "1.0 - ";
-        AppendSource(shader, source, index_name);
-        shader += ".g";
+        out += "1.0 - ";
+        AppendSource(out, source, index_name);
+        out += ".g";
         break;
     case AlphaModifier::SourceBlue:
-        AppendSource(shader, source, index_name);
-        shader += ".b";
+        AppendSource(out, source, index_name);
+        out += ".b";
         break;
     case AlphaModifier::OneMinusSourceBlue:
-        shader += "1.0 - ";
-        AppendSource(shader, source, index_name);
-        shader += ".b";
+        out += "1.0 - ";
+        AppendSource(out, source, index_name);
+        out += ".b";
         break;
     default:
-        shader += "vec3(0.0)";
+        out += "vec3(0.0)";
         LOG_CRITICAL(Render_OpenGL, "Unknown alpha modifier op %u", modifier);
         break;
     }
 }
 
-static void AppendColorCombiner(std::string& shader, Pica::Regs::TevStageConfig::Operation operation,
+static void AppendColorCombiner(std::string& out, TevStageConfig::Operation operation,
         const std::string& variable_name) {
-    using Operation = Pica::Regs::TevStageConfig::Operation;
+    using Operation = TevStageConfig::Operation;
 
     switch (operation) {
     case Operation::Replace:
-        shader += variable_name + "[0]";
+        out += variable_name + "[0]";
         break;
     case Operation::Modulate:
-        shader += variable_name + "[0] * " + variable_name + "[1]";
+        out += variable_name + "[0] * " + variable_name + "[1]";
         break;
     case Operation::Add:
-        shader += "min(" + variable_name + "[0] + " + variable_name + "[1], vec3(1.0))";
+        out += "min(" + variable_name + "[0] + " + variable_name + "[1], vec3(1.0))";
         break;
     case Operation::AddSigned:
-        shader += "clamp(" + variable_name + "[0] + " + variable_name + "[1] - vec3(0.5), vec3(0.0), vec3(1.0))";
+        out += "clamp(" + variable_name + "[0] + " + variable_name + "[1] - vec3(0.5), vec3(0.0), vec3(1.0))";
         break;
     case Operation::Lerp:
-        shader += variable_name + "[0] * " + variable_name + "[2] + " + variable_name + "[1] * (vec3(1.0) - " + variable_name + "[2])";
+        out += variable_name + "[0] * " + variable_name + "[2] + " + variable_name + "[1] * (vec3(1.0) - " + variable_name + "[2])";
         break;
     case Operation::Subtract:
-        shader += "max(" + variable_name + "[0] - " + variable_name + "[1], vec3(0.0))";
+        out += "max(" + variable_name + "[0] - " + variable_name + "[1], vec3(0.0))";
         break;
     case Operation::MultiplyThenAdd:
-        shader += "min(" + variable_name + "[0] * " + variable_name + "[1] + " + variable_name + "[2], vec3(1.0))";
+        out += "min(" + variable_name + "[0] * " + variable_name + "[1] + " + variable_name + "[2], vec3(1.0))";
         break;
     case Operation::AddThenMultiply:
-        shader += "min(" + variable_name + "[0] + " + variable_name + "[1], vec3(1.0)) * " + variable_name + "[2]";
+        out += "min(" + variable_name + "[0] + " + variable_name + "[1], vec3(1.0)) * " + variable_name + "[2]";
         break;
     default:
-        shader += "vec3(0.0)";
-        LOG_CRITICAL(Render_OpenGL, "Unknown color comb op %u", operation);
+        out += "vec3(0.0)";
+        LOG_CRITICAL(Render_OpenGL, "Unknown color combiner operation: %u", operation);
         break;
     }
 }
 
-static void AppendAlphaCombiner(std::string& shader, Pica::Regs::TevStageConfig::Operation operation,
+static void AppendAlphaCombiner(std::string& out, TevStageConfig::Operation operation,
         const std::string& variable_name) {
-    using Operation = Pica::Regs::TevStageConfig::Operation;
+    using Operation = TevStageConfig::Operation;
     switch (operation) {
     case Operation::Replace:
-        shader += variable_name + "[0]";
+        out += variable_name + "[0]";
         break;
     case Operation::Modulate:
-        shader += variable_name + "[0] * " + variable_name + "[1]";
+        out += variable_name + "[0] * " + variable_name + "[1]";
         break;
     case Operation::Add:
-        shader += "min(" + variable_name + "[0] + " + variable_name + "[1], 1.0)";
+        out += "min(" + variable_name + "[0] + " + variable_name + "[1], 1.0)";
         break;
     case Operation::AddSigned:
-        shader += "clamp(" + variable_name + "[0] + " + variable_name + "[1] - 0.5, 0.0, 1.0)";
+        out += "clamp(" + variable_name + "[0] + " + variable_name + "[1] - 0.5, 0.0, 1.0)";
         break;
     case Operation::Lerp:
-        shader += variable_name + "[0] * " + variable_name + "[2] + " + variable_name + "[1] * (1.0 - " + variable_name + "[2])";
+        out += variable_name + "[0] * " + variable_name + "[2] + " + variable_name + "[1] * (1.0 - " + variable_name + "[2])";
         break;
     case Operation::Subtract:
-        shader += "max(" + variable_name + "[0] - " + variable_name + "[1], 0.0)";
+        out += "max(" + variable_name + "[0] - " + variable_name + "[1], 0.0)";
         break;
     case Operation::MultiplyThenAdd:
-        shader += "min(" + variable_name + "[0] * " + variable_name + "[1] + " + variable_name + "[2], 1.0)";
+        out += "min(" + variable_name + "[0] * " + variable_name + "[1] + " + variable_name + "[2], 1.0)";
         break;
     case Operation::AddThenMultiply:
-        shader += "min(" + variable_name + "[0] + " + variable_name + "[1], 1.0) * " + variable_name + "[2]";
+        out += "min(" + variable_name + "[0] + " + variable_name + "[1], 1.0) * " + variable_name + "[2]";
         break;
     default:
-        shader += "0.0";
-        LOG_CRITICAL(Render_OpenGL, "Unknown alpha combiner op %u", operation);
+        out += "0.0";
+        LOG_CRITICAL(Render_OpenGL, "Unknown alpha combiner operation: %u", operation);
         break;
     }
 }
 
-static void AppendAlphaTestCondition(std::string& shader, Pica::Regs::CompareFunc func) {
-    using CompareFunc = Pica::Regs::CompareFunc;
+static void AppendAlphaTestCondition(std::string& out, Regs::CompareFunc func) {
+    using CompareFunc = Regs::CompareFunc;
     switch (func) {
     case CompareFunc::Never:
-        shader += "true";
+        out += "true";
         break;
     case CompareFunc::Always:
-        shader += "false";
+        out += "false";
         break;
     case CompareFunc::Equal:
-        shader += "int(g_last_tex_env_out.a * 255.0f) != alphatest_ref";
+        out += "int(g_last_tex_env_out.a * 255.0f) != alphatest_ref";
         break;
     case CompareFunc::NotEqual:
-        shader += "int(g_last_tex_env_out.a * 255.0f) == alphatest_ref";
+        out += "int(g_last_tex_env_out.a * 255.0f) == alphatest_ref";
         break;
     case CompareFunc::LessThan:
-        shader += "int(g_last_tex_env_out.a * 255.0f) >= alphatest_ref";
+        out += "int(g_last_tex_env_out.a * 255.0f) >= alphatest_ref";
         break;
     case CompareFunc::LessThanOrEqual:
-        shader += "int(g_last_tex_env_out.a * 255.0f) > alphatest_ref";
+        out += "int(g_last_tex_env_out.a * 255.0f) > alphatest_ref";
         break;
     case CompareFunc::GreaterThan:
-        shader += "int(g_last_tex_env_out.a * 255.0f) <= alphatest_ref";
+        out += "int(g_last_tex_env_out.a * 255.0f) <= alphatest_ref";
         break;
     case CompareFunc::GreaterThanOrEqual:
-        shader += "int(g_last_tex_env_out.a * 255.0f) < alphatest_ref";
+        out += "int(g_last_tex_env_out.a * 255.0f) < alphatest_ref";
         break;
     default:
-        shader += "false";
+        out += "false";
         LOG_CRITICAL(Render_OpenGL, "Unknown alpha test condition %u", func);
         break;
     }
 }
 
+static void WriteTevStage(std::string& out, const ShaderCacheKey& config, unsigned index) {
+    auto& stage = config.tev_stages[index];
+    if (!IsPassThroughTevStage(stage)) {
+        std::string index_name = std::to_string(index);
+
+        out += "vec3 color_results_" + index_name + "[3] = vec3[3](";
+        AppendColorModifier(out, stage.color_modifier1, stage.color_source1, index_name);
+        out += ", ";
+        AppendColorModifier(out, stage.color_modifier2, stage.color_source2, index_name);
+        out += ", ";
+        AppendColorModifier(out, stage.color_modifier3, stage.color_source3, index_name);
+        out += ");\n";
+
+        out += "vec3 color_output_" + index_name + " = ";
+        AppendColorCombiner(out, stage.color_op, "color_results_" + index_name);
+        out += ";\n";
+
+        out += "float alpha_results_" + index_name + "[3] = float[3](";
+        AppendAlphaModifier(out, stage.alpha_modifier1, stage.alpha_source1, index_name);
+        out += ", ";
+        AppendAlphaModifier(out, stage.alpha_modifier2, stage.alpha_source2, index_name);
+        out += ", ";
+        AppendAlphaModifier(out, stage.alpha_modifier3, stage.alpha_source3, index_name);
+        out += ");\n";
+
+        out += "float alpha_output_" + index_name + " = ";
+        AppendAlphaCombiner(out, stage.alpha_op, "alpha_results_" + index_name);
+        out += ";\n";
+
+        out += "g_last_tex_env_out = vec4(min(color_output_" + index_name + " * " +
+            std::to_string(stage.GetColorMultiplier()) + ".0, 1.0), min(alpha_output_" + index_name + " * " +
+            std::to_string(stage.GetAlphaMultiplier()) + ".0, 1.0));\n";
+    }
+
+    if (config.TevStageUpdatesCombinerBufferColor(index))
+        out += "g_combiner_buffer.rgb = g_last_tex_env_out.rgb;\n";
+
+    if (config.TevStageUpdatesCombinerBufferAlpha(index))
+        out += "g_combiner_buffer.a = g_last_tex_env_out.a;\n";
+}
+
 std::string GenerateFragmentShader(const ShaderCacheKey& config) {
-    std::string shader = R"(
+    std::string out = R"(
 #version 150 core
 
 #define NUM_VTX_ATTR 7
@@ -288,63 +333,27 @@ vec4 g_last_tex_env_out = vec4(0.0, 0.0, 0.0, 0.0);
 )";
 
     // Do not do any sort of processing if it's obvious we're not going to pass the alpha test
-    if (config.alpha_test_func == Pica::Regs::CompareFunc::Never) {
-        shader += "discard;";
-        return shader;
+    if (config.alpha_test_func == Regs::CompareFunc::Never) {
+        out += "discard;";
+        return out;
     }
 
-    auto& tev_stages = config.tev_stages;
-    for (unsigned tev_stage_index = 0; tev_stage_index < tev_stages.size(); ++tev_stage_index) {
-        auto& tev_stage = tev_stages[tev_stage_index];
-        if (!IsPassThroughTevStage(tev_stage)) {
-            std::string index_name = std::to_string(tev_stage_index);
-
-            shader += "vec3 color_results_" + index_name + "[3] = vec3[3](";
-            AppendColorModifier(shader, tev_stage.color_modifier1, tev_stage.color_source1, index_name);
-            shader += ", ";
-            AppendColorModifier(shader, tev_stage.color_modifier2, tev_stage.color_source2, index_name);
-            shader += ", ";
-            AppendColorModifier(shader, tev_stage.color_modifier3, tev_stage.color_source3, index_name);
-            shader += ");\n";
-
-            shader += "vec3 color_output_" + index_name + " = ";
-            AppendColorCombiner(shader, tev_stage.color_op, "color_results_" + index_name);
-            shader += ";\n";
-
-            shader += "float alpha_results_" + index_name + "[3] = float[3](";
-            AppendAlphaModifier(shader, tev_stage.alpha_modifier1, tev_stage.alpha_source1, index_name);
-            shader += ", ";
-            AppendAlphaModifier(shader, tev_stage.alpha_modifier2, tev_stage.alpha_source2, index_name);
-            shader += ", ";
-            AppendAlphaModifier(shader, tev_stage.alpha_modifier3, tev_stage.alpha_source3, index_name);
-            shader += ");\n";
-
-            shader += "float alpha_output_" + index_name + " = ";
-            AppendAlphaCombiner(shader, tev_stage.alpha_op, "alpha_results_" + index_name);
-            shader += ";\n";
-
-            shader += "g_last_tex_env_out = vec4(min(color_output_" + index_name + " * " + std::to_string(tev_stage.GetColorMultiplier()) + ".0, 1.0), min(alpha_output_" + index_name + " * " + std::to_string(tev_stage.GetAlphaMultiplier()) + ".0, 1.0));\n";
-        }
-
-        if (config.TevStageUpdatesCombinerBufferColor(tev_stage_index))
-            shader += "g_combiner_buffer.rgb = g_last_tex_env_out.rgb;\n";
-
-        if (config.TevStageUpdatesCombinerBufferAlpha(tev_stage_index))
-            shader += "g_combiner_buffer.a = g_last_tex_env_out.a;\n";
-    }
+    for (std::size_t index = 0; index < config.tev_stages.size(); ++index)
+        WriteTevStage(out, config, (unsigned)index);
 
-    if (config.alpha_test_func != Pica::Regs::CompareFunc::Always) {
-        shader += "if (";
-        AppendAlphaTestCondition(shader, config.alpha_test_func);
-        shader += ") {\n discard;\n }\n";
+    if (config.alpha_test_func != Regs::CompareFunc::Always) {
+        out += "if (";
+        AppendAlphaTestCondition(out, config.alpha_test_func);
+        out += ") {\n discard;\n }\n";
     }
 
-    shader += "color = g_last_tex_env_out;\n}";
-    return shader;
+    out += "color = g_last_tex_env_out;\n}";
+
+    return out;
 }
 
 std::string GenerateVertexShader() {
-    static const std::string shader_str = R"(
+    static const std::string out = R"(
 #version 150 core
 
 #define NUM_VTX_ATTR 7
@@ -365,7 +374,7 @@ void main() {
     gl_Position = vec4(vert_position.x, -vert_position.y, -vert_position.z, vert_position.w);
 }
 )";
-    return shader_str;
+    return out;
 }
 
-} // namespace GLShaderGen
+} // namespace GLShader