summaryrefslogtreecommitdiffstats
path: root/src/video_core
diff options
context:
space:
mode:
Diffstat (limited to 'src/video_core')
-rw-r--r--src/video_core/CMakeLists.txt2
-rw-r--r--src/video_core/shader/glsl_decompiler.cpp1393
-rw-r--r--src/video_core/shader/glsl_decompiler.h88
3 files changed, 1483 insertions, 0 deletions
diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt
index e9e324386..86b06487d 100644
--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -84,6 +84,8 @@ add_library(video_core STATIC
shader/decode/xmad.cpp
shader/decode/other.cpp
shader/decode.cpp
+ shader/glsl_decompiler.cpp
+ shader/glsl_decompiler.h
shader/shader_ir.cpp
shader/shader_ir.h
surface.cpp
diff --git a/src/video_core/shader/glsl_decompiler.cpp b/src/video_core/shader/glsl_decompiler.cpp
new file mode 100644
index 000000000..46a48652d
--- /dev/null
+++ b/src/video_core/shader/glsl_decompiler.cpp
@@ -0,0 +1,1393 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <string>
+#include <string_view>
+#include <variant>
+
+#include <fmt/format.h>
+
+#include "common/alignment.h"
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "video_core/engines/maxwell_3d.h"
+#include "video_core/shader/glsl_decompiler.h"
+#include "video_core/shader/shader_ir.h"
+
+namespace OpenGL::GLShader {
+
+using Tegra::Shader::Attribute;
+using Tegra::Shader::Header;
+using Tegra::Shader::IpaInterpMode;
+using Tegra::Shader::IpaMode;
+using Tegra::Shader::IpaSampleMode;
+using namespace VideoCommon::Shader;
+
+using Maxwell = Tegra::Engines::Maxwell3D::Regs;
+using ShaderStage = Tegra::Engines::Maxwell3D::Regs::ShaderStage;
+using Operation = const OperationNode&;
+
+enum : u32 { POSITION_VARYING_LOCATION = 0, GENERIC_VARYING_START_LOCATION = 1 };
+constexpr u32 MAX_CONSTBUFFER_ELEMENTS = 65536 / 16; // TODO(Rodrigo): Use rasterizer's value
+
+enum class Type { Bool, Float, Int, Uint, HalfFloat };
+
+class ShaderWriter {
+public:
+ void AddExpression(std::string_view text) {
+ DEBUG_ASSERT(scope >= 0);
+ if (!text.empty()) {
+ AppendIndentation();
+ }
+ shader_source += text;
+ }
+
+ void AddLine(std::string_view text) {
+ AddExpression(text);
+ AddNewLine();
+ }
+
+ void AddLine(char character) {
+ DEBUG_ASSERT(scope >= 0);
+ AppendIndentation();
+ shader_source += character;
+ AddNewLine();
+ }
+
+ void AddNewLine() {
+ DEBUG_ASSERT(scope >= 0);
+ shader_source += '\n';
+ }
+
+ std::string GenerateTemporal() {
+ std::string temporal = "tmp";
+ temporal += std::to_string(temporal_index++);
+ return temporal;
+ }
+
+ std::string GetResult() {
+ return std::move(shader_source);
+ }
+
+ s32 scope = 0;
+
+private:
+ void AppendIndentation() {
+ shader_source.append(static_cast<std::size_t>(scope) * 4, ' ');
+ }
+
+ std::string shader_source;
+ u32 temporal_index = 1;
+};
+
+/// Generates code to use for a swizzle operation.
+static std::string GetSwizzle(u32 elem) {
+ ASSERT(elem <= 3);
+ std::string swizzle = ".";
+ swizzle += "xyzw"[elem];
+ return swizzle;
+}
+
+static bool IsPrecise(Operation operand) {
+ const auto& meta = operand.GetMeta();
+
+ if (std::holds_alternative<MetaArithmetic>(meta)) {
+ return std::get<MetaArithmetic>(meta).precise;
+ }
+ if (std::holds_alternative<MetaHalfArithmetic>(meta)) {
+ return std::get<MetaHalfArithmetic>(meta).precise;
+ }
+ return false;
+}
+
+static bool IsPrecise(Node node) {
+ if (!std::holds_alternative<OperationNode>(*node)) {
+ return false;
+ }
+ return IsPrecise(std::get<OperationNode>(*node));
+}
+
+class GLSLDecompiler final {
+public:
+ explicit GLSLDecompiler(const ShaderIR& ir, ShaderStage stage, std::string suffix)
+ : ir{ir}, stage{stage}, suffix{suffix}, header{ir.GetHeader()} {}
+
+ void Decompile() {
+ DeclareVertex();
+ DeclareRegisters();
+ DeclarePredicates();
+ DeclareLocalMemory();
+ DeclareInternalFlags();
+ DeclareInputAttributes();
+ DeclareOutputAttributes();
+ DeclareConstantBuffers();
+ DeclareSamplers();
+
+ code.AddLine("void execute_" + suffix + "() {");
+ ++code.scope;
+
+ // VM's program counter
+ const auto first_address = ir.GetBasicBlocks().begin()->first;
+ code.AddLine("uint jmp_to = " + std::to_string(first_address) + "u;");
+
+ // TODO(Subv): Figure out the actual depth of the flow stack, for now it seems
+ // unlikely that shaders will use 20 nested SSYs and PBKs.
+ constexpr u32 FLOW_STACK_SIZE = 20;
+ code.AddLine(fmt::format("uint flow_stack[{}];", FLOW_STACK_SIZE));
+ code.AddLine("uint flow_stack_top = 0u;");
+
+ code.AddLine("while (true) {");
+ ++code.scope;
+
+ code.AddLine("switch (jmp_to) {");
+
+ for (const auto& pair : ir.GetBasicBlocks()) {
+ const auto [address, bb] = pair;
+ code.AddLine(fmt::format("case 0x{:x}u: {{", address));
+ ++code.scope;
+
+ VisitBasicBlock(bb);
+
+ --code.scope;
+ code.AddLine('}');
+ }
+
+ code.AddLine("default: return;");
+ code.AddLine('}');
+
+ for (std::size_t i = 0; i < 2; ++i) {
+ --code.scope;
+ code.AddLine('}');
+ }
+ }
+
+ std::string GetResult() {
+ return code.GetResult();
+ }
+
+ ShaderEntries GetShaderEntries() const {
+ ShaderEntries entries;
+ for (const auto& cbuf : ir.GetConstantBuffers()) {
+ ConstBufferEntry desc(cbuf.second, stage, GetConstBufferBlock(cbuf.first), cbuf.first);
+ entries.const_buffers.push_back(desc);
+ }
+ for (const auto& sampler : ir.GetSamplers()) {
+ SamplerEntry desc(sampler, stage, GetSampler(sampler));
+ entries.samplers.push_back(desc);
+ }
+ entries.clip_distances = ir.GetClipDistances();
+ entries.shader_length = ir.GetLength();
+ return entries;
+ }
+
+private:
+ using OperationDecompilerFn = std::string (GLSLDecompiler::*)(Operation);
+ using OperationDecompilersArray =
+ std::array<OperationDecompilerFn, static_cast<std::size_t>(OperationCode::Amount)>;
+
+ void DeclareVertex() {
+ if (stage != ShaderStage::Vertex)
+ return;
+
+ bool clip_distances_declared = false;
+
+ code.AddLine("out gl_PerVertex {");
+ ++code.scope;
+
+ code.AddLine("vec4 gl_Position;");
+
+ for (const auto o : ir.GetOutputAttributes()) {
+ if (o == Attribute::Index::PointSize)
+ code.AddLine("float gl_PointSize;");
+ if (!clip_distances_declared && (o == Attribute::Index::ClipDistances0123 ||
+ o == Attribute::Index::ClipDistances4567)) {
+ code.AddLine("float gl_ClipDistance[];");
+ clip_distances_declared = true;
+ }
+ }
+
+ --code.scope;
+ code.AddLine("};");
+ code.AddNewLine();
+ }
+
+ void DeclareRegisters() {
+ const auto& registers = ir.GetRegisters();
+ for (const u32 gpr : registers) {
+ code.AddLine("float " + GetRegister(gpr) + " = 0;");
+ }
+ if (!registers.empty())
+ code.AddNewLine();
+ }
+
+ void DeclarePredicates() {
+ const auto& predicates = ir.GetPredicates();
+ for (const auto pred : predicates) {
+ code.AddLine("bool " + GetPredicate(pred) + " = false;");
+ }
+ if (!predicates.empty())
+ code.AddNewLine();
+ }
+
+ void DeclareLocalMemory() {
+ if (const u64 local_memory_size = header.GetLocalMemorySize(); local_memory_size > 0) {
+ const auto element_count = Common::AlignUp(local_memory_size, 4) / 4;
+ code.AddLine("float " + GetLocalMemory() + '[' + std::to_string(element_count) + "];");
+ code.AddNewLine();
+ }
+ }
+
+ void DeclareInternalFlags() {
+ for (u32 flag = 0; flag < static_cast<u32>(InternalFlag::Amount); flag++) {
+ const InternalFlag flag_code = static_cast<InternalFlag>(flag);
+ code.AddLine("bool " + GetInternalFlag(flag_code) + " = false;");
+ }
+ code.AddNewLine();
+ }
+
+ std::string GetInputFlags(const IpaMode& input_mode) {
+ const IpaSampleMode sample_mode = input_mode.sampling_mode;
+ const IpaInterpMode interp_mode = input_mode.interpolation_mode;
+ std::string out;
+
+ switch (interp_mode) {
+ case IpaInterpMode::Flat:
+ out += "flat ";
+ break;
+ case IpaInterpMode::Linear:
+ out += "noperspective ";
+ break;
+ case IpaInterpMode::Perspective:
+ // Default, Smooth
+ break;
+ default:
+ UNIMPLEMENTED_MSG("Unhandled IPA interp mode: {}", static_cast<u32>(interp_mode));
+ }
+ switch (sample_mode) {
+ case IpaSampleMode::Centroid:
+ // It can be implemented with the "centroid " keyword in GLSL
+ UNIMPLEMENTED_MSG("Unimplemented IPA sampler mode centroid");
+ break;
+ case IpaSampleMode::Default:
+ // Default, n/a
+ break;
+ default:
+ UNIMPLEMENTED_MSG("Unimplemented IPA sampler mode: {}", static_cast<u32>(sample_mode));
+ }
+ return out;
+ }
+
+ void DeclareInputAttributes() {
+ const auto& attributes = ir.GetInputAttributes();
+ for (const auto element : attributes) {
+ const Attribute::Index index = element.first;
+ const IpaMode& input_mode = *element.second.begin();
+ if (index < Attribute::Index::Attribute_0 || index > Attribute::Index::Attribute_31) {
+ // Skip when it's not a generic attribute
+ continue;
+ }
+
+ ASSERT(element.second.size() > 0);
+ // UNIMPLEMENTED_IF_MSG(element.second.size() > 1,
+ // "Multiple input flag modes are not supported in GLSL");
+
+ // TODO(bunnei): Use proper number of elements for these
+ u32 idx = static_cast<u32>(index) - static_cast<u32>(Attribute::Index::Attribute_0);
+ if (stage != ShaderStage::Vertex) {
+ // If inputs are varyings, add an offset
+ idx += GENERIC_VARYING_START_LOCATION;
+ }
+
+ std::string attr = GetInputAttribute(index);
+ if (stage == ShaderStage::Geometry) {
+ attr = "gs_" + attr + "[]";
+ }
+ code.AddLine("layout (location = " + std::to_string(idx) + ") " +
+ GetInputFlags(input_mode) + "in vec4 " + attr + ';');
+ }
+ if (!attributes.empty())
+ code.AddNewLine();
+ }
+
+ void DeclareOutputAttributes() {
+ const auto& attributes = ir.GetOutputAttributes();
+ for (const auto index : attributes) {
+ if (index < Attribute::Index::Attribute_0 || index > Attribute::Index::Attribute_31) {
+ // Skip when it's not a generic attribute
+ continue;
+ }
+ // TODO(bunnei): Use proper number of elements for these
+ const auto idx = static_cast<u32>(index) -
+ static_cast<u32>(Attribute::Index::Attribute_0) +
+ GENERIC_VARYING_START_LOCATION;
+ code.AddLine("layout (location = " + std::to_string(idx) + ") out vec4 " +
+ GetOutputAttribute(index) + ';');
+ }
+ if (!attributes.empty())
+ code.AddNewLine();
+ }
+
+ void DeclareConstantBuffers() {
+ for (const auto& entry : ir.GetConstantBuffers()) {
+ const auto [index, size] = entry;
+ code.AddLine("layout (std140) uniform " + GetConstBufferBlock(index) + " {");
+ code.AddLine(" vec4 " + GetConstBuffer(index) + "[MAX_CONSTBUFFER_ELEMENTS];");
+ code.AddLine("};");
+ code.AddNewLine();
+ }
+ }
+
+ void DeclareSamplers() {
+ const auto& samplers = ir.GetSamplers();
+ for (const auto& sampler : samplers) {
+ std::string sampler_type = [&]() {
+ switch (sampler.GetType()) {
+ case Tegra::Shader::TextureType::Texture1D:
+ return "sampler1D";
+ case Tegra::Shader::TextureType::Texture2D:
+ return "sampler2D";
+ case Tegra::Shader::TextureType::Texture3D:
+ return "sampler3D";
+ case Tegra::Shader::TextureType::TextureCube:
+ return "samplerCube";
+ default:
+ UNREACHABLE();
+ }
+ }();
+ if (sampler.IsArray())
+ sampler_type += "Array";
+ if (sampler.IsShadow())
+ sampler_type += "Shadow";
+
+ code.AddLine("uniform " + sampler_type + ' ' + GetSampler(sampler) + ';');
+ }
+ if (!samplers.empty())
+ code.AddNewLine();
+ }
+
+ void VisitBasicBlock(const BasicBlock& bb) {
+ for (const Node node : bb) {
+ if (const std::string expr = Visit(node); !expr.empty()) {
+ code.AddLine(expr);
+ }
+ }
+ }
+
+ std::string Visit(Node node) {
+ if (const auto operation = std::get_if<OperationNode>(node)) {
+ const auto operation_index = static_cast<std::size_t>(operation->GetCode());
+ const auto decompiler = operation_decompilers[operation_index];
+ if (decompiler == nullptr) {
+ UNREACHABLE_MSG("Operation decompiler {} not defined", operation_index);
+ }
+ return (this->*decompiler)(*operation);
+
+ } else if (const auto gpr = std::get_if<GprNode>(node)) {
+ const u32 index = gpr->GetIndex();
+ if (index == RZ) {
+ return "0";
+ }
+ return GetRegister(index);
+
+ } else if (const auto immediate = std::get_if<ImmediateNode>(node)) {
+ const u32 value = immediate->GetValue();
+ if (value < 10) {
+ // For eyecandy avoid using hex numbers on single digits
+ return fmt::format("utof({}u)", immediate->GetValue());
+ }
+ return fmt::format("utof(0x{:x}u)", immediate->GetValue());
+
+ } else if (const auto predicate = std::get_if<PredicateNode>(node)) {
+ const auto value = [&]() -> std::string {
+ switch (const auto index = predicate->GetIndex(); index) {
+ case Tegra::Shader::Pred::UnusedIndex:
+ return "true";
+ case Tegra::Shader::Pred::NeverExecute:
+ return "false";
+ default:
+ return GetPredicate(index);
+ }
+ }();
+ if (predicate->IsNegated()) {
+ return "!(" + value + ')';
+ }
+ return value;
+
+ } else if (const auto abuf = std::get_if<AbufNode>(node)) {
+ const auto attribute = abuf->GetIndex();
+ const auto element = abuf->GetElement();
+
+ switch (attribute) {
+ case Attribute::Index::Position:
+ return element == 3 ? "1.0f" : "gl_FragCoord" + GetSwizzle(element);
+ case Attribute::Index::PointCoord:
+ switch (element) {
+ case 0:
+ return "gl_PointCoord.x";
+ case 1:
+ return "gl_PointCoord.y";
+ case 2:
+ case 3:
+ return "0";
+ }
+ UNREACHABLE();
+ return "0";
+ case Attribute::Index::TessCoordInstanceIDVertexID:
+ // TODO(Subv): Find out what the values are for the first two elements when inside a
+ // vertex shader, and what's the value of the fourth element when inside a Tess Eval
+ // shader.
+ ASSERT(stage == ShaderStage::Vertex);
+ switch (element) {
+ case 2:
+ // Config pack's first value is instance_id.
+ return "uintBitsToFloat(config_pack[0])";
+ case 3:
+ return "uintBitsToFloat(gl_VertexID)";
+ }
+ UNIMPLEMENTED_MSG("Unmanaged TessCoordInstanceIDVertexID element={}", element);
+ return "0";
+ case Attribute::Index::FrontFacing:
+ // TODO(Subv): Find out what the values are for the other elements.
+ ASSERT(stage == ShaderStage::Fragment);
+ switch (element) {
+ case 3:
+ return "itof(gl_FrontFacing ? -1 : 0)";
+ }
+ UNIMPLEMENTED_MSG("Unmanaged FrontFacing element={}", element);
+ return "0";
+ default:
+ if (attribute >= Attribute::Index::Attribute_0 &&
+ attribute <= Attribute::Index::Attribute_31) {
+ return GetInputAttribute(attribute) + GetSwizzle(abuf->GetElement());
+ }
+ break;
+ }
+ UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
+
+ } else if (const auto cbuf = std::get_if<CbufNode>(node)) {
+ const Node offset = cbuf->GetOffset();
+ if (const auto immediate = std::get_if<ImmediateNode>(offset)) {
+ // Direct access
+ const u32 offset_imm = immediate->GetValue();
+ return fmt::format("{}[{}][{}]", GetConstBuffer(cbuf->GetIndex()), offset_imm / 4,
+ offset_imm % 4);
+
+ } else if (std::holds_alternative<OperationNode>(*offset)) {
+ // Indirect access
+ const std::string final_offset = code.GenerateTemporal();
+ code.AddLine("uint " + final_offset + " = (ftou(" + Visit(offset) + ") / 4) & " +
+ std::to_string(MAX_CONSTBUFFER_ELEMENTS - 1) + ';');
+ return fmt::format("{}[{} / 4][{} % 4]", GetConstBuffer(cbuf->GetIndex()),
+ final_offset, final_offset);
+
+ } else {
+ UNREACHABLE_MSG("Unmanaged offset node type");
+ }
+
+ } else if (const auto lmem = std::get_if<LmemNode>(node)) {
+ return fmt::format("{}[ftou({}) / 4]", GetLocalMemory(), Visit(lmem->GetAddress()));
+
+ } else if (const auto internal_flag = std::get_if<InternalFlagNode>(node)) {
+ return GetInternalFlag(internal_flag->GetFlag());
+
+ } else if (const auto conditional = std::get_if<ConditionalNode>(node)) {
+ // It's invalid to call conditional on nested nodes, use an operation instead
+ code.AddLine("if (" + Visit(conditional->GetCondition()) + ") {");
+ ++code.scope;
+
+ VisitBasicBlock(conditional->GetCode());
+
+ --code.scope;
+ code.AddLine('}');
+ return {};
+
+ } else if (const auto comment = std::get_if<CommentNode>(node)) {
+ return "// " + comment->GetText();
+ }
+ UNREACHABLE();
+ }
+
+ std::string ApplyPrecise(Operation operation, const std::string& value) {
+ if (!IsPrecise(operation)) {
+ return value;
+ }
+ // There's a bug in NVidia's proprietary drivers that makes precise fail on fragment shaders
+ const std::string precise = stage != ShaderStage::Fragment ? "precise " : "";
+
+ const std::string temporal = code.GenerateTemporal();
+ code.AddLine(precise + "float " + temporal + " = " + value + ';');
+ return temporal;
+ }
+
+ std::string VisitOperand(Operation operation, std::size_t operand_index) {
+ const auto& operand = operation[operand_index];
+ const bool parent_precise = IsPrecise(operation);
+ const bool child_precise = IsPrecise(operand);
+ const bool child_trivial = !std::holds_alternative<OperationNode>(*operand);
+ if (!parent_precise || child_precise || child_trivial) {
+ return Visit(operand);
+ }
+
+ const std::string temporal = code.GenerateTemporal();
+ code.AddLine("float " + temporal + " = " + Visit(operand) + ';');
+ return temporal;
+ }
+
+ std::string VisitOperand(Operation operation, std::size_t operand_index, Type type) {
+ std::string value = VisitOperand(operation, operand_index);
+
+ switch (type) {
+ case Type::Bool:
+ case Type::Float:
+ return value;
+ case Type::Int:
+ return "ftoi(" + value + ')';
+ case Type::Uint:
+ return "ftou(" + value + ')';
+ case Type::HalfFloat:
+ if (!std::holds_alternative<MetaHalfArithmetic>(operation.GetMeta())) {
+ value = "toHalf2(" + value + ')';
+ }
+
+ const auto& half_meta = std::get<MetaHalfArithmetic>(operation.GetMeta());
+ switch (half_meta.types.at(operand_index)) {
+ case Tegra::Shader::HalfType::H0_H1:
+ return "toHalf2(" + value + ')';
+ case Tegra::Shader::HalfType::F32:
+ return "vec2(" + value + ')';
+ case Tegra::Shader::HalfType::H0_H0:
+ return "vec2(toHalf2(" + value + ")[0])";
+ case Tegra::Shader::HalfType::H1_H1:
+ return "vec2(toHalf2(" + value + ")[1])";
+ }
+ }
+ UNREACHABLE();
+ }
+
+ std::string BitwiseCastResult(std::string value, Type type, bool needs_parenthesis = false) {
+ switch (type) {
+ case Type::Bool:
+ case Type::Float:
+ if (needs_parenthesis) {
+ return '(' + value + ')';
+ }
+ return value;
+ case Type::Int:
+ return "itof(" + value + ')';
+ case Type::Uint:
+ return "utof(" + value + ')';
+ case Type::HalfFloat:
+ return "fromHalf2(" + value + ')';
+ }
+ UNREACHABLE();
+ }
+
+ std::string GenerateUnary(Operation operation, const std::string& func, Type result_type,
+ Type type_a, bool needs_parenthesis = true) {
+ return ApplyPrecise(operation,
+ BitwiseCastResult(func + '(' + VisitOperand(operation, 0, type_a) + ')',
+ result_type, needs_parenthesis));
+ }
+
+ std::string GenerateBinaryInfix(Operation operation, const std::string& func, Type result_type,
+ Type type_a, Type type_b) {
+ const std::string op_a = VisitOperand(operation, 0, type_a);
+ const std::string op_b = VisitOperand(operation, 1, type_b);
+
+ return ApplyPrecise(
+ operation, BitwiseCastResult('(' + op_a + ' ' + func + ' ' + op_b + ')', result_type));
+ }
+
+ std::string GenerateBinaryCall(Operation operation, const std::string& func, Type result_type,
+ Type type_a, Type type_b) {
+ const std::string op_a = VisitOperand(operation, 0, type_a);
+ const std::string op_b = VisitOperand(operation, 1, type_b);
+
+ return ApplyPrecise(operation,
+ BitwiseCastResult(func + '(' + op_a + ", " + op_b + ')', result_type));
+ }
+
+ std::string GenerateTernary(Operation operation, const std::string& func, Type result_type,
+ Type type_a, Type type_b, Type type_c) {
+ const std::string op_a = VisitOperand(operation, 0, type_a);
+ const std::string op_b = VisitOperand(operation, 1, type_b);
+ const std::string op_c = VisitOperand(operation, 2, type_c);
+
+ return ApplyPrecise(
+ operation,
+ BitwiseCastResult(func + '(' + op_a + ", " + op_b + ", " + op_c + ')', result_type));
+ }
+
+ std::string GenerateQuaternary(Operation operation, const std::string& func, Type result_type,
+ Type type_a, Type type_b, Type type_c, Type type_d) {
+ const std::string op_a = VisitOperand(operation, 0, type_a);
+ const std::string op_b = VisitOperand(operation, 1, type_b);
+ const std::string op_c = VisitOperand(operation, 2, type_c);
+ const std::string op_d = VisitOperand(operation, 3, type_d);
+
+ return ApplyPrecise(operation, BitwiseCastResult(func + '(' + op_a + ", " + op_b + ", " +
+ op_c + ", " + op_d + ')',
+ result_type));
+ }
+
+ std::string GenerateTexture(Operation operation, const std::string& func,
+ const std::string& extra_cast = "") {
+ constexpr std::array<const char*, 4> coord_constructors = {"float", "vec2", "vec3", "vec4"};
+
+ const auto& meta = std::get<MetaTexture>(operation.GetMeta());
+ const auto count = static_cast<u32>(operation.GetOperandsCount());
+
+ std::string expr = func;
+ expr += '(';
+ expr += GetSampler(meta.sampler);
+ expr += ", ";
+
+ expr += coord_constructors[meta.coords_count - 1];
+ expr += '(';
+ for (u32 i = 0; i < count; ++i) {
+ const bool is_extra = i >= meta.coords_count;
+ const bool do_cast = is_extra && !extra_cast.empty();
+ if (do_cast) {
+ expr += extra_cast;
+ expr += '(';
+ }
+ expr += Visit(operation[i]);
+ if (do_cast) {
+ expr += ')';
+ }
+ if (i + 1 == meta.coords_count) {
+ expr += ')';
+ }
+ if (i + 1 < count) {
+ expr += ", ";
+ }
+ }
+ expr += ')';
+ return expr;
+ }
+
+ std::string Assign(Operation operation) {
+ const Node dest = operation[0];
+ const Node src = operation[1];
+
+ std::string target;
+ if (const auto gpr = std::get_if<GprNode>(dest)) {
+ if (gpr->GetIndex() == RZ) {
+ // Writing to RZ is a no op
+ return {};
+ }
+ target = GetRegister(gpr->GetIndex());
+
+ } else if (const auto abuf = std::get_if<AbufNode>(dest)) {
+ target = [&]() -> std::string {
+ switch (const auto attribute = abuf->GetIndex(); abuf->GetIndex()) {
+ case Attribute::Index::Position:
+ return "position" + GetSwizzle(abuf->GetElement());
+ case Attribute::Index::PointSize:
+ return "gl_PointSize";
+ case Attribute::Index::ClipDistances0123:
+ return "gl_ClipDistance[" + std::to_string(abuf->GetElement()) + ']';
+ case Attribute::Index::ClipDistances4567:
+ return "gl_ClipDistance[" + std::to_string(abuf->GetElement() + 4) + ']';
+ default:
+ if (attribute >= Attribute::Index::Attribute_0 &&
+ attribute <= Attribute::Index::Attribute_31) {
+ return GetOutputAttribute(attribute) + GetSwizzle(abuf->GetElement());
+ }
+ UNIMPLEMENTED_MSG("Unhandled output attribute: {}",
+ static_cast<u32>(attribute));
+ }
+ }();
+
+ } else if (const auto lmem = std::get_if<LmemNode>(dest)) {
+ target = GetLocalMemory() + "[ftou(" + Visit(lmem->GetAddress()) + ") / 4]";
+
+ } else {
+ UNREACHABLE_MSG("Assign called without a proper target");
+ }
+
+ code.AddLine(target + " = " + Visit(src) + ';');
+ return {};
+ }
+
+ std::string AssignComposite(Operation operation) {
+ const auto& meta = std::get<MetaComponents>(operation.GetMeta());
+
+ const std::string composite = code.GenerateTemporal();
+ code.AddLine("vec4 " + composite + " = " + Visit(operation[0]) + ';');
+
+ constexpr u32 composite_size = 4;
+ for (u32 i = 0; i < composite_size; ++i) {
+ const auto gpr = std::get<GprNode>(*operation[i + 1]).GetIndex();
+ if (gpr == RZ) {
+ continue;
+ }
+ code.AddLine(GetRegister(gpr) + " = " + composite +
+ GetSwizzle(meta.GetSourceComponent(i)) + ';');
+ }
+ return {};
+ }
+
+ std::string Composite(Operation operation) {
+ std::string value = "vec4(";
+ for (std::size_t i = 0; i < 4; ++i) {
+ value += Visit(operation[i]);
+ if (i < 3)
+ value += ", ";
+ }
+ value += ')';
+ return value;
+ }
+
+ template <Type type>
+ std::string Add(Operation operation) {
+ return GenerateBinaryInfix(operation, "+", type, type, type);
+ }
+
+ template <Type type>
+ std::string Mul(Operation operation) {
+ return GenerateBinaryInfix(operation, "*", type, type, type);
+ }
+
+ template <Type type>
+ std::string Div(Operation operation) {
+ return GenerateBinaryInfix(operation, "/", type, type, type);
+ }
+
+ std::string FFma(Operation operation) {
+ return GenerateTernary(operation, "fma", Type::Float, Type::Float, Type::Float,
+ Type::Float);
+ }
+
+ template <Type type>
+ std::string Negate(Operation operation) {
+ return GenerateUnary(operation, "-", type, type, true);
+ }
+
+ template <Type type>
+ std::string Absolute(Operation operation) {
+ return GenerateUnary(operation, "abs", type, type, false);
+ }
+
+ std::string FClamp(Operation operation) {
+ return GenerateTernary(operation, "clamp", Type::Float, Type::Float, Type::Float,
+ Type::Float);
+ }
+
+ template <Type type>
+ std::string Min(Operation operation) {
+ return GenerateBinaryCall(operation, "min", type, type, type);
+ }
+
+ template <Type type>
+ std::string Max(Operation operation) {
+ return GenerateBinaryCall(operation, "max", type, type, type);
+ }
+
+ std::string Select(Operation operation) {
+ const std::string condition = Visit(operation[0]);
+ const std::string true_case = Visit(operation[1]);
+ const std::string false_case = Visit(operation[2]);
+ return ApplyPrecise(operation,
+ '(' + condition + " ? " + true_case + " : " + false_case + ')');
+ }
+
+ std::string FCos(Operation operation) {
+ return GenerateUnary(operation, "cos", Type::Float, Type::Float, false);
+ }
+
+ std::string FSin(Operation operation) {
+ return GenerateUnary(operation, "sin", Type::Float, Type::Float, false);
+ }
+
+ std::string FExp2(Operation operation) {
+ return GenerateUnary(operation, "exp2", Type::Float, Type::Float, false);
+ }
+
+ std::string FLog2(Operation operation) {
+ return GenerateUnary(operation, "log2", Type::Float, Type::Float, false);
+ }
+
+ std::string FInverseSqrt(Operation operation) {
+ return GenerateUnary(operation, "inversesqrt", Type::Float, Type::Float, false);
+ }
+
+ std::string FSqrt(Operation operation) {
+ return GenerateUnary(operation, "sqrt", Type::Float, Type::Float, false);
+ }
+
+ std::string FRoundEven(Operation operation) {
+ return GenerateUnary(operation, "roundEven", Type::Float, Type::Float, false);
+ }
+
+ std::string FFloor(Operation operation) {
+ return GenerateUnary(operation, "floor", Type::Float, Type::Float, false);
+ }
+
+ std::string FCeil(Operation operation) {
+ return GenerateUnary(operation, "ceil", Type::Float, Type::Float, false);
+ }
+
+ std::string FTrunc(Operation operation) {
+ return GenerateUnary(operation, "trunc", Type::Float, Type::Float, false);
+ }
+
+ template <Type type>
+ std::string FCastInteger(Operation operation) {
+ return GenerateUnary(operation, "float", Type::Float, type, false);
+ }
+
+ std::string ICastFloat(Operation operation) {
+ return GenerateUnary(operation, "int", Type::Int, Type::Float, false);
+ }
+
+ std::string ICastUnsigned(Operation operation) {
+ return GenerateUnary(operation, "int", Type::Int, Type::Uint, false);
+ }
+
+ template <Type type>
+ std::string LogicalShiftLeft(Operation operation) {
+ return GenerateBinaryInfix(operation, "<<", type, type, Type::Uint);
+ }
+
+ std::string ILogicalShiftRight(Operation operation) {
+ const std::string op_a = VisitOperand(operation, 0, Type::Uint);
+ const std::string op_b = VisitOperand(operation, 1, Type::Uint);
+
+ return ApplyPrecise(operation,
+ BitwiseCastResult("int(" + op_a + " >> " + op_b + ')', Type::Int));
+ }
+
+ std::string IArithmeticShiftRight(Operation operation) {
+ return GenerateBinaryInfix(operation, ">>", Type::Int, Type::Int, Type::Uint);
+ }
+
+ template <Type type>
+ std::string BitwiseAnd(Operation operation) {
+ return GenerateBinaryInfix(operation, "&", type, type, type);
+ }
+
+ template <Type type>
+ std::string BitwiseOr(Operation operation) {
+ return GenerateBinaryInfix(operation, "|", type, type, type);
+ }
+
+ template <Type type>
+ std::string BitwiseXor(Operation operation) {
+ return GenerateBinaryInfix(operation, "^", type, type, type);
+ }
+
+ template <Type type>
+ std::string BitwiseNot(Operation operation) {
+ return GenerateUnary(operation, "~", type, type, false);
+ }
+
+ std::string UCastFloat(Operation operation) {
+ return GenerateUnary(operation, "uint", Type::Uint, Type::Float, false);
+ }
+
+ std::string UCastSigned(Operation operation) {
+ return GenerateUnary(operation, "uint", Type::Uint, Type::Int, false);
+ }
+
+ std::string UShiftRight(Operation operation) {
+ return GenerateBinaryInfix(operation, ">>", Type::Uint, Type::Uint, Type::Uint);
+ }
+
+ template <Type type>
+ std::string BitfieldInsert(Operation operation) {
+ return GenerateQuaternary(operation, "bitfieldInsert", type, type, type, Type::Int,
+ Type::Int);
+ }
+
+ std::string HNegate(Operation operation) {
+ const auto GetNegate = [&](std::size_t index) -> std::string {
+ if (const auto pred = std::get_if<PredicateNode>(operation[index])) {
+ if (!pred->IsNegated()) {
+ switch (pred->GetIndex()) {
+ case Tegra::Shader::Pred::UnusedIndex:
+ return "-1";
+ case Tegra::Shader::Pred::NeverExecute:
+ return "1";
+ }
+ }
+ }
+ return VisitOperand(operation, index, Type::Bool) + " ? -1 : 1";
+ };
+ const std::string value = '(' + VisitOperand(operation, 0, Type::HalfFloat) + " * vec2(" +
+ GetNegate(1) + ", " + GetNegate(2) + "))";
+ return BitwiseCastResult(value, Type::HalfFloat);
+ }
+
+ std::string HMergeF32(Operation operation) {
+ return "float(toHalf2(" + Visit(operation[0]) + ")[0])";
+ }
+
+ std::string HMergeH0(Operation operation) {
+ return "fromHalf2(vec2(toHalf2(" + Visit(operation[0]) + ")[1], toHalf2(" +
+ Visit(operation[1]) + ")[0]))";
+ }
+
+ std::string HMergeH1(Operation operation) {
+ return "fromHalf2(vec2(toHalf2(" + Visit(operation[0]) + ")[0], toHalf2(" +
+ Visit(operation[1]) + ")[1]))";
+ }
+
+ template <Type type>
+ std::string LogicalLessThan(Operation operation) {
+ return GenerateBinaryInfix(operation, "<", Type::Bool, type, type);
+ }
+
+ template <Type type>
+ std::string LogicalEqual(Operation operation) {
+ return GenerateBinaryInfix(operation, "==", Type::Bool, type, type);
+ }
+
+ template <Type type>
+ std::string LogicalLessEqual(Operation operation) {
+ return GenerateBinaryInfix(operation, "<=", Type::Bool, type, type);
+ }
+
+ template <Type type>
+ std::string LogicalGreaterThan(Operation operation) {
+ return GenerateBinaryInfix(operation, ">", Type::Bool, type, type);
+ }
+
+ template <Type type>
+ std::string LogicalNotEqual(Operation operation) {
+ return GenerateBinaryInfix(operation, "!=", Type::Bool, type, type);
+ }
+
+ template <Type type>
+ std::string LogicalGreaterEqual(Operation operation) {
+ return GenerateBinaryInfix(operation, ">=", Type::Bool, type, type);
+ }
+
+ std::string LogicalFIsNan(Operation operation) {
+ return GenerateUnary(operation, "isnan", Type::Bool, Type::Float, false);
+ }
+
+ std::string LogicalAssign(Operation operation) {
+ const Node dest = operation[0];
+ const Node src = operation[1];
+
+ std::string target;
+
+ if (const auto pred = std::get_if<PredicateNode>(dest)) {
+ ASSERT_MSG(!pred->IsNegated(), "Negating logical assignment");
+
+ const auto index = pred->GetIndex();
+ switch (index) {
+ case Tegra::Shader::Pred::NeverExecute:
+ case Tegra::Shader::Pred::UnusedIndex:
+ // Writing to these predicates is a no-op
+ return {};
+ }
+ target = GetPredicate(index);
+ } else if (const auto flag = std::get_if<InternalFlagNode>(dest)) {
+ target = GetInternalFlag(flag->GetFlag());
+ }
+
+ code.AddLine(target + " = " + Visit(src) + ';');
+ return {};
+ }
+
+ std::string LogicalAnd(Operation operation) {
+ return GenerateBinaryInfix(operation, "&&", Type::Bool, Type::Bool, Type::Bool);
+ }
+
+ std::string LogicalOr(Operation operation) {
+ return GenerateBinaryInfix(operation, "||", Type::Bool, Type::Bool, Type::Bool);
+ }
+
+ std::string LogicalXor(Operation operation) {
+ return GenerateBinaryInfix(operation, "^^", Type::Bool, Type::Bool, Type::Bool);
+ }
+
+ std::string LogicalNegate(Operation operation) {
+ return GenerateUnary(operation, "!", Type::Bool, Type::Bool, false);
+ }
+
+ std::string LogicalHComparison(Operation operation, const std::string& func) {
+ const auto& meta = std::get<MetaHalfArithmetic>(operation.GetMeta());
+ const std::string op_a = VisitOperand(operation, 0, Type::HalfFloat);
+ const std::string op_b = VisitOperand(operation, 1, Type::HalfFloat);
+
+ std::string value = meta.and_comparison ? "all" : "any";
+ value += '(' + func + '(' + op_a + ", " + op_b + "))";
+ return value;
+ }
+
+ std::string LogicalHLessThan(Operation operation) {
+ return LogicalHComparison(operation, "lessThan");
+ }
+
+ std::string LogicalHEqual(Operation operation) {
+ return LogicalHComparison(operation, "equal");
+ }
+
+ std::string LogicalHLessEqual(Operation operation) {
+ return LogicalHComparison(operation, "lessThanEqual");
+ }
+
+ std::string LogicalHGreaterThan(Operation operation) {
+ return LogicalHComparison(operation, "greaterThan");
+ }
+
+ std::string LogicalHNotEqual(Operation operation) {
+ return LogicalHComparison(operation, "notEqual");
+ }
+
+ std::string LogicalHGreaterEqual(Operation operation) {
+ return LogicalHComparison(operation, "greaterThanEqual");
+ }
+
+ std::string F4Texture(Operation operation) {
+ std::string expr = GenerateTexture(operation, "texture");
+ if (std::get<MetaTexture>(operation.GetMeta()).sampler.IsShadow()) {
+ expr = "vec4(" + expr + ')';
+ }
+ return expr;
+ }
+
+ std::string F4TextureLod(Operation operation) {
+ std::string expr = GenerateTexture(operation, "textureLod");
+ if (std::get<MetaTexture>(operation.GetMeta()).sampler.IsShadow()) {
+ expr = "vec4(" + expr + ')';
+ }
+ return expr;
+ }
+
+ std::string F4TextureGather(Operation operation) {
+ return GenerateTexture(operation, "textureGather", "int");
+ }
+
+ std::string F4TextureQueryDimensions(Operation operation) {
+ const auto& meta = std::get<MetaTexture>(operation.GetMeta());
+ const std::string sampler = GetSampler(meta.sampler);
+ const std::string lod = VisitOperand(operation, 0, Type::Int);
+
+ const std::string sizes = code.GenerateTemporal();
+ code.AddLine("ivec2 " + sizes + " = textureSize(" + sampler + ", " + lod + ");");
+
+ const std::string mip_level = "textureQueryLevels(" + sampler + ')';
+
+ return "itof(ivec4(" + sizes + ", 0, " + mip_level + "))";
+ }
+
+ std::string F4TextureQueryLod(Operation operation) {
+ const std::string tmp = code.GenerateTemporal();
+ code.AddLine("vec2 " + tmp + " = " + GenerateTexture(operation, "textureQueryLod") +
+ " * vec2(256);");
+
+ return "vec4(itof(int(" + tmp + ".y)), utof(uint(" + tmp + ".x)), 0, 0)";
+ }
+
+ std::string Ipa(Operation operation) {
+ const auto& attribute = operation[0];
+ // TODO(Rodrigo): Special IPA attribute interactions
+ return Visit(attribute);
+ }
+
+ std::string Bra(Operation operation) {
+ const auto target = std::get<ImmediateNode>(*operation[0]);
+ code.AddLine(fmt::format("jmp_to = 0x{:x}u;", target.GetValue()));
+ code.AddLine("break;");
+ return {};
+ }
+
+ std::string PushFlowStack(Operation operation) {
+ const auto target = std::get<ImmediateNode>(*operation[0]);
+ code.AddLine(fmt::format("flow_stack[flow_stack_top] = 0x{:x}u;", target.GetValue()));
+ code.AddLine("flow_stack_top++;");
+ return {};
+ }
+
+ std::string PopFlowStack(Operation operation) {
+ code.AddLine("flow_stack_top--;");
+ code.AddLine("jmp_to = flow_stack[flow_stack_top];");
+ code.AddLine("break;");
+ return {};
+ }
+
+ std::string Exit(Operation operation) {
+ if (stage != ShaderStage::Fragment) {
+ code.AddLine("return;");
+ return {};
+ }
+ const auto& used_registers = ir.GetRegisters();
+ const auto SafeGetRegister = [&](u32 reg) -> std::string {
+ // TODO(Rodrigo): Replace with contains once C++20 releases
+ if (used_registers.find(reg) != used_registers.end()) {
+ return GetRegister(reg);
+ }
+ return "0.0f";
+ };
+
+ UNIMPLEMENTED_IF_MSG(header.ps.omap.sample_mask != 0, "Sample mask write is unimplemented");
+
+ code.AddLine("if (alpha_test[0] != 0) {");
+ ++code.scope;
+ // We start on the register containing the alpha value in the first RT.
+ u32 current_reg = 3;
+ for (u32 render_target = 0; render_target < Maxwell::NumRenderTargets; ++render_target) {
+ // TODO(Blinkhawk): verify the behavior of alpha testing on hardware when
+ // multiple render targets are used.
+ if (header.ps.IsColorComponentOutputEnabled(render_target, 0) ||
+ header.ps.IsColorComponentOutputEnabled(render_target, 1) ||
+ header.ps.IsColorComponentOutputEnabled(render_target, 2) ||
+ header.ps.IsColorComponentOutputEnabled(render_target, 3)) {
+ code.AddLine(
+ fmt::format("if (!AlphaFunc({})) discard;", SafeGetRegister(current_reg)));
+ current_reg += 4;
+ }
+ }
+ --code.scope;
+ code.AddLine('}');
+
+ // Write the color outputs using the data in the shader registers, disabled
+ // rendertargets/components are skipped in the register assignment.
+ current_reg = 0;
+ for (u32 render_target = 0; render_target < Maxwell::NumRenderTargets; ++render_target) {
+ // TODO(Subv): Figure out how dual-source blending is configured in the Switch.
+ for (u32 component = 0; component < 4; ++component) {
+ if (header.ps.IsColorComponentOutputEnabled(render_target, component)) {
+ code.AddLine(fmt::format("FragColor{}[{}] = {};", render_target, component,
+ SafeGetRegister(current_reg)));
+ ++current_reg;
+ }
+ }
+ }
+
+ if (header.ps.omap.depth) {
+ // The depth output is always 2 registers after the last color output, and current_reg
+ // already contains one past the last color register.
+ code.AddLine("gl_FragDepth = " + SafeGetRegister(current_reg + 1) + ';');
+ }
+
+ code.AddLine("return;");
+ return {};
+ }
+
+ std::string Kil(Operation operation) {
+ // Enclose "discard" in a conditional, so that GLSL compilation does not complain
+ // about unexecuted instructions that may follow this.
+ code.AddLine("if (true) {");
+ ++code.scope;
+ code.AddLine("discard;");
+ --code.scope;
+ code.AddLine("}");
+ return {};
+ }
+
+ std::string YNegate(Operation operation) {
+ // Config pack's third value is Y_NEGATE's state.
+ return "uintBitsToFloat(config_pack[2])";
+ }
+
+ static constexpr OperationDecompilersArray operation_decompilers = {
+ &Assign,
+ &AssignComposite,
+
+ &Composite,
+ &Select,
+
+ &Add<Type::Float>,
+ &Mul<Type::Float>,
+ &Div<Type::Float>,
+ &FFma,
+ &Negate<Type::Float>,
+ &Absolute<Type::Float>,
+ &FClamp,
+ &Min<Type::Float>,
+ &Max<Type::Float>,
+ &FCos,
+ &FSin,
+ &FExp2,
+ &FLog2,
+ &FInverseSqrt,
+ &FSqrt,
+ &FRoundEven,
+ &FFloor,
+ &FCeil,
+ &FTrunc,
+ &FCastInteger<Type::Int>,
+ &FCastInteger<Type::Uint>,
+
+ &Add<Type::Int>,
+ &Mul<Type::Int>,
+ &Div<Type::Int>,
+ &Negate<Type::Int>,
+ &Absolute<Type::Int>,
+ &Min<Type::Int>,
+ &Max<Type::Int>,
+
+ &ICastFloat,
+ &ICastUnsigned,
+ &LogicalShiftLeft<Type::Int>,
+ &ILogicalShiftRight,
+ &IArithmeticShiftRight,
+ &BitwiseAnd<Type::Int>,
+ &BitwiseOr<Type::Int>,
+ &BitwiseXor<Type::Int>,
+ &BitwiseNot<Type::Int>,
+ &BitfieldInsert<Type::Int>,
+
+ &Add<Type::Uint>,
+ &Mul<Type::Uint>,
+ &Div<Type::Uint>,
+ &Min<Type::Uint>,
+ &Max<Type::Uint>,
+ &UCastFloat,
+ &UCastSigned,
+ &LogicalShiftLeft<Type::Uint>,
+ &UShiftRight,
+ &UShiftRight,
+ &BitwiseAnd<Type::Uint>,
+ &BitwiseOr<Type::Uint>,
+ &BitwiseXor<Type::Uint>,
+ &BitwiseNot<Type::Uint>,
+ &BitfieldInsert<Type::Uint>,
+
+ &Add<Type::HalfFloat>,
+ &Mul<Type::HalfFloat>,
+ &Absolute<Type::HalfFloat>,
+ &HNegate,
+ &HMergeF32,
+ &HMergeH0,
+ &HMergeH1,
+
+ &LogicalAssign,
+ &LogicalAnd,
+ &LogicalOr,
+ &LogicalXor,
+ &LogicalNegate,
+
+ &LogicalLessThan<Type::Float>,
+ &LogicalEqual<Type::Float>,
+ &LogicalLessEqual<Type::Float>,
+ &LogicalGreaterThan<Type::Float>,
+ &LogicalNotEqual<Type::Float>,
+ &LogicalGreaterEqual<Type::Float>,
+ &LogicalFIsNan,
+
+ &LogicalLessThan<Type::Int>,
+ &LogicalEqual<Type::Int>,
+ &LogicalLessEqual<Type::Int>,
+ &LogicalGreaterThan<Type::Int>,
+ &LogicalNotEqual<Type::Int>,
+ &LogicalGreaterEqual<Type::Int>,
+
+ &LogicalLessThan<Type::Uint>,
+ &LogicalEqual<Type::Uint>,
+ &LogicalLessEqual<Type::Uint>,
+ &LogicalGreaterThan<Type::Uint>,
+ &LogicalNotEqual<Type::Uint>,
+ &LogicalGreaterEqual<Type::Uint>,
+
+ &LogicalHLessThan,
+ &LogicalHEqual,
+ &LogicalHLessEqual,
+ &LogicalHGreaterThan,
+ &LogicalHNotEqual,
+ &LogicalHGreaterEqual,
+
+ &F4Texture,
+ &F4TextureLod,
+ &F4TextureGather,
+ &F4TextureQueryDimensions,
+ &F4TextureQueryLod,
+
+ &Ipa,
+
+ &Bra,
+ &PushFlowStack, // Ssy
+ &PushFlowStack, // Brk
+ &PopFlowStack, // Sync
+ &PopFlowStack, // Brk
+ &Exit,
+ &Kil,
+
+ &YNegate,
+ };
+
+ std::string GetRegister(u32 index) const {
+ return GetDeclarationWithSuffix(index, "gpr");
+ }
+
+ std::string GetPredicate(Tegra::Shader::Pred pred) const {
+ return GetDeclarationWithSuffix(static_cast<u32>(pred), "pred");
+ }
+
+ std::string GetInputAttribute(Attribute::Index attribute) const {
+ const auto index{static_cast<u32>(attribute) -
+ static_cast<u32>(Attribute::Index::Attribute_0)};
+ return GetDeclarationWithSuffix(index, "input_attr");
+ }
+
+ std::string GetOutputAttribute(Attribute::Index attribute) const {
+ const auto index{static_cast<u32>(attribute) -
+ static_cast<u32>(Attribute::Index::Attribute_0)};
+ return GetDeclarationWithSuffix(index, "output_attr");
+ }
+
+ std::string GetConstBuffer(u32 index) const {
+ return GetDeclarationWithSuffix(index, "cbuf");
+ }
+
+ std::string GetConstBufferBlock(u32 index) const {
+ return GetDeclarationWithSuffix(index, "cbuf_block");
+ }
+
+ std::string GetLocalMemory() const {
+ return "lmem_" + suffix;
+ }
+
+ std::string GetInternalFlag(InternalFlag flag) const {
+ constexpr std::array<const char*, 4> InternalFlagNames = {"zero_flag", "sign_flag",
+ "carry_flag", "overflow_flag"};
+ const auto index = static_cast<u32>(flag);
+ ASSERT(index < static_cast<u32>(InternalFlag::Amount));
+
+ return std::string(InternalFlagNames[index]) + '_' + suffix;
+ }
+
+ std::string GetSampler(const Sampler& sampler) const {
+ return GetDeclarationWithSuffix(sampler.GetIndex(), "sampler");
+ }
+
+ std::string GetDeclarationWithSuffix(u32 index, const std::string& name) const {
+ return name + '_' + std::to_string(index) + '_' + suffix;
+ }
+
+ const ShaderIR& ir;
+ const ShaderStage stage;
+ const std::string suffix;
+ const Header header;
+
+ ShaderWriter code;
+};
+
+std::string GetCommonDeclarations() {
+ return "#define MAX_CONSTBUFFER_ELEMENTS " + std::to_string(MAX_CONSTBUFFER_ELEMENTS) +
+ "\n"
+ "#define ftoi floatBitsToInt\n"
+ "#define ftou floatBitsToUint\n"
+ "#define itof intBitsToFloat\n"
+ "#define utof uintBitsToFloat\n\n"
+ "float fromHalf2(vec2 pair) {\n"
+ " return utof(packHalf2x16(pair));\n"
+ "}\n\n"
+ "vec2 toHalf2(float value) {\n"
+ " return unpackHalf2x16(ftou(value));\n"
+ "}\n\n";
+}
+
+ProgramResult Decompile(const ShaderIR& ir, Maxwell::ShaderStage stage, const std::string& suffix) {
+ GLSLDecompiler decompiler(ir, stage, suffix);
+ decompiler.Decompile();
+ return {decompiler.GetResult(), decompiler.GetShaderEntries()};
+}
+
+} // namespace OpenGL::GLShader \ No newline at end of file
diff --git a/src/video_core/shader/glsl_decompiler.h b/src/video_core/shader/glsl_decompiler.h
new file mode 100644
index 000000000..7be461f1b
--- /dev/null
+++ b/src/video_core/shader/glsl_decompiler.h
@@ -0,0 +1,88 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <string>
+#include <utility>
+#include <vector>
+#include "common/common_types.h"
+#include "video_core/engines/maxwell_3d.h"
+#include "video_core/shader/shader_ir.h"
+
+namespace VideoCommon::Shader {
+class ShaderIR;
+}
+
+namespace OpenGL::GLShader {
+
+using Maxwell = Tegra::Engines::Maxwell3D::Regs;
+
+class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer {
+public:
+ explicit ConstBufferEntry(const VideoCommon::Shader::ConstBuffer& entry,
+ Maxwell::ShaderStage stage, const std::string& name, u32 index)
+ : VideoCommon::Shader::ConstBuffer{entry}, stage{stage}, name{name}, index{index} {}
+
+ const std::string& GetName() const {
+ return name;
+ }
+
+ Maxwell::ShaderStage GetStage() const {
+ return stage;
+ }
+
+ u32 GetIndex() const {
+ return index;
+ }
+
+ u32 GetHash() const {
+ return (static_cast<u32>(stage) << 16) | index;
+ }
+
+private:
+ std::string name;
+ Maxwell::ShaderStage stage{};
+ u32 index{};
+};
+
+class SamplerEntry : public VideoCommon::Shader::Sampler {
+public:
+ explicit SamplerEntry(const VideoCommon::Shader::Sampler& entry, Maxwell::ShaderStage stage,
+ const std::string& name)
+ : VideoCommon::Shader::Sampler{entry}, stage{stage}, name{name} {}
+
+ const std::string& GetName() const {
+ return name;
+ }
+
+ Maxwell::ShaderStage GetStage() const {
+ return stage;
+ }
+
+ u32 GetHash() const {
+ return (static_cast<u32>(stage) << 16) | GetIndex();
+ }
+
+private:
+ std::string name;
+ Maxwell::ShaderStage stage{};
+};
+
+struct ShaderEntries {
+ std::vector<ConstBufferEntry> const_buffers;
+ std::vector<SamplerEntry> samplers;
+ std::array<bool, Maxwell::NumClipDistances> clip_distances{};
+ std::size_t shader_length{};
+};
+
+using ProgramResult = std::pair<std::string, ShaderEntries>;
+
+std::string GetCommonDeclarations();
+
+ProgramResult Decompile(const VideoCommon::Shader::ShaderIR& ir, Maxwell::ShaderStage stage,
+ const std::string& suffix);
+
+} // namespace OpenGL::GLShader \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 13:05:42 +0100