From 4dd85f86a89338ff84d05a3981c14f6de1be4606 Mon Sep 17 00:00:00 2001
From: Feng Chen <vonchenplus@gmail.com>
Date: Fri, 19 Nov 2021 15:32:53 +0800
Subject: Implement convert legacy to generic

---
 .../frontend/maxwell/translate_program.cpp         | 95 ++++++++++++++++++++++
 .../frontend/maxwell/translate_program.h           |  4 +
 2 files changed, 99 insertions(+)

(limited to 'src/shader_recompiler/frontend/maxwell')

diff --git a/src/shader_recompiler/frontend/maxwell/translate_program.cpp b/src/shader_recompiler/frontend/maxwell/translate_program.cpp
index 267ebe4af..40c9307db 100644
--- a/src/shader_recompiler/frontend/maxwell/translate_program.cpp
+++ b/src/shader_recompiler/frontend/maxwell/translate_program.cpp
@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
+#include <queue>
 
 #include "common/settings.h"
 #include "shader_recompiler/exception.h"
@@ -226,4 +227,98 @@ IR::Program MergeDualVertexPrograms(IR::Program& vertex_a, IR::Program& vertex_b
     return result;
 }
 
+bool IsLegacyAttribute(IR::Attribute attribute) {
+    return (attribute >= IR::Attribute::ColorFrontDiffuseR &&
+            attribute <= IR::Attribute::ColorBackSpecularA) ||
+           attribute == IR::Attribute::FogCoordinate ||
+           (attribute >= IR::Attribute::FixedFncTexture0S &&
+            attribute <= IR::Attribute::FixedFncTexture9Q);
+}
+
+std::map<IR::Attribute, IR::Attribute> GenerateLegacyToGenericMappings(
+    const VaryingState& state, std::queue<IR::Attribute> ununsed_generics) {
+    std::map<IR::Attribute, IR::Attribute> mapping;
+    for (size_t index = 0; index < 4; ++index) {
+        auto attr = IR::Attribute::ColorFrontDiffuseR + index * 4;
+        if (state.AnyComponent(attr)) {
+            for (size_t i = 0; i < 4; ++i) {
+                mapping.insert({attr + i, ununsed_generics.front() + i});
+            }
+            ununsed_generics.pop();
+        }
+    }
+    if (state[IR::Attribute::FogCoordinate]) {
+        mapping.insert({IR::Attribute::FogCoordinate, ununsed_generics.front()});
+        ununsed_generics.pop();
+    }
+    for (size_t index = 0; index < IR::NUM_FIXED_FNC_TEXTURES; ++index) {
+        auto attr = IR::Attribute::FixedFncTexture0S + index * 4;
+        if (state.AnyComponent(attr)) {
+            for (size_t i = 0; i < 4; ++i) {
+                mapping.insert({attr + i, ununsed_generics.front() + i});
+            }
+            ununsed_generics.pop();
+        }
+    }
+    return mapping;
+}
+
+void ConvertLegacyToGeneric(IR::Program& program, const Shader::RuntimeInfo& runtime_info) {
+    auto& stores = program.info.stores;
+    if (stores.Legacy()) {
+        std::queue<IR::Attribute> ununsed_output_generics{};
+        for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
+            if (!stores.Generic(index)) {
+                ununsed_output_generics.push(IR::Attribute::Generic0X + index * 4);
+            }
+        }
+        auto mappings = GenerateLegacyToGenericMappings(stores, ununsed_output_generics);
+        for (IR::Block* const block : program.post_order_blocks) {
+            for (IR::Inst& inst : block->Instructions()) {
+                switch (inst.GetOpcode()) {
+                case IR::Opcode::SetAttribute: {
+                    const auto attr = inst.Arg(0).Attribute();
+                    if (IsLegacyAttribute(attr)) {
+                        stores.Set(mappings[attr], true);
+                        inst.SetArg(0, Shader::IR::Value(mappings[attr]));
+                    }
+                    break;
+                }
+                default:
+                    break;
+                }
+            }
+        }
+    }
+
+    auto& loads = program.info.loads;
+    if (loads.Legacy()) {
+        std::queue<IR::Attribute> ununsed_input_generics{};
+        for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
+            const AttributeType input_type{runtime_info.generic_input_types[index]};
+            if (!runtime_info.previous_stage_stores.Generic(index) || !loads.Generic(index) ||
+                input_type == AttributeType::Disabled) {
+                ununsed_input_generics.push(IR::Attribute::Generic0X + index * 4);
+            }
+        }
+        auto mappings = GenerateLegacyToGenericMappings(loads, ununsed_input_generics);
+        for (IR::Block* const block : program.post_order_blocks) {
+            for (IR::Inst& inst : block->Instructions()) {
+                switch (inst.GetOpcode()) {
+                case IR::Opcode::GetAttribute: {
+                    const auto attr = inst.Arg(0).Attribute();
+                    if (IsLegacyAttribute(attr)) {
+                        loads.Set(mappings[attr], true);
+                        inst.SetArg(0, Shader::IR::Value(mappings[attr]));
+                    }
+                    break;
+                }
+                default:
+                    break;
+                }
+            }
+        }
+    }
+}
+
 } // namespace Shader::Maxwell
diff --git a/src/shader_recompiler/frontend/maxwell/translate_program.h b/src/shader_recompiler/frontend/maxwell/translate_program.h
index a84814811..cd535f20d 100644
--- a/src/shader_recompiler/frontend/maxwell/translate_program.h
+++ b/src/shader_recompiler/frontend/maxwell/translate_program.h
@@ -10,6 +10,7 @@
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
 #include "shader_recompiler/host_translate_info.h"
 #include "shader_recompiler/object_pool.h"
+#include "shader_recompiler/runtime_info.h"
 
 namespace Shader::Maxwell {
 
@@ -20,4 +21,7 @@ namespace Shader::Maxwell {
 [[nodiscard]] IR::Program MergeDualVertexPrograms(IR::Program& vertex_a, IR::Program& vertex_b,
                                                   Environment& env_vertex_b);
 
+[[nodiscard]] void ConvertLegacyToGeneric(IR::Program& program,
+                                          const Shader::RuntimeInfo& runtime_info);
+
 } // namespace Shader::Maxwell
-- 
cgit v1.2.3