Linuxydable/suyu
1
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity
suyu/src/video_core/renderer_opengl/gl_shader_decompiler.cpp

2900 lines
104 KiB
C++
Raw Normal View History

glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// Copyright 2018 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
shader_ir: Remove composite primitives and use temporals instead
2018-12-27 05:50:22 +01:00
#include <array>
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
#include <string>
#include <string_view>
shader/decode: Remove extras from MetaTexture
2019-02-22 07:30:12 +01:00
#include <utility>
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
#include <variant>
shader/decode: Remove extras from MetaTexture
2019-02-22 07:30:12 +01:00
#include <vector>
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
#include <fmt/format.h>
#include "common/alignment.h"
#include "common/assert.h"
#include "common/common_types.h"
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
#include "common/logging/log.h"
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
#include "video_core/engines/maxwell_3d.h"
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
#include "video_core/engines/shader_type.h"
gl_shader_decompiler: Use variable AOFFI on supported hardware
2019-04-10 23:03:52 +02:00
#include "video_core/renderer_opengl/gl_device.h"
gl_shader_decompiler: Use rasterizer's UBO size limit
2018-12-26 06:14:06 +01:00
#include "video_core/renderer_opengl/gl_rasterizer.h"
video_core: Rename glsl_decompiler to gl_shader_decompiler
2018-12-26 05:57:14 +01:00
#include "video_core/renderer_opengl/gl_shader_decompiler.h"
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
#include "video_core/shader/ast.h"
vk_shader_decompiler: Clean code and be const correct.
2019-09-24 16:57:45 +02:00
#include "video_core/shader/node.h"
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
#include "video_core/shader/shader_ir.h"
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
#include "video_core/shader/transform_feedback.h"
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
namespace OpenGL {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Hide local definitions inside an anonymous namespace
2019-03-31 05:24:10 +02:00
namespace {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
using Tegra::Engines::ShaderType;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
using Tegra::Shader::Attribute;
using Tegra::Shader::Header;
using Tegra::Shader::IpaInterpMode;
using Tegra::Shader::IpaMode;
using Tegra::Shader::IpaSampleMode;
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
using Tegra::Shader::PixelImap;
shader_ir: Remove RZ and use Register::ZeroIndex instead
2018-12-26 05:49:32 +01:00
using Tegra::Shader::Register;
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
using VideoCommon::Shader::BuildTransformFeedback;
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
using VideoCommon::Shader::Registry;
gl_shader_decompiler: Make GetSwizzle constexpr
2019-05-03 07:59:25 +02:00
using namespace std::string_literals;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
using namespace VideoCommon::Shader;
using Maxwell = Tegra::Engines::Maxwell3D::Regs;
using Operation = const OperationNode&;
gl_shader_cache: Remove dynamic BaseBinding specialization
2019-11-19 01:38:15 +01:00
class ASTDecompiler;
class ExprDecompiler;
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
enum class Type { Void, Bool, Bool2, Float, Int, Uint, HalfFloat };
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
constexpr std::array FLOAT_TYPES{"float", "vec2", "vec3", "vec4"};
constexpr std::string_view INPUT_ATTRIBUTE_NAME = "in_attr";
constexpr std::string_view OUTPUT_ATTRIBUTE_NAME = "out_attr";
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
struct TextureOffset {};
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
struct TextureDerivates {};
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
using TextureArgument = std::pair<Type, Node>;
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
using TextureIR = std::variant<TextureOffset, TextureDerivates, TextureArgument>;
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
gl_shader_decompiler: Use rasterizer's UBO size limit
2018-12-26 06:14:06 +01:00
constexpr u32 MAX_CONSTBUFFER_ELEMENTS =
gl_rasterizer: Minor style changes
2019-07-06 04:11:58 +02:00
static_cast<u32>(Maxwell::MaxConstBufferSize) / (4 * sizeof(float));
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader/registry: Address feedback
2020-03-02 05:08:10 +01:00
constexpr std::string_view CommonDeclarations = R"(#define ftoi floatBitsToInt
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
#define ftou floatBitsToUint
#define itof intBitsToFloat
#define utof uintBitsToFloat
bvec2 HalfFloatNanComparison(bvec2 comparison, vec2 pair1, vec2 pair2) {{
bvec2 is_nan1 = isnan(pair1);
bvec2 is_nan2 = isnan(pair2);
return bvec2(comparison.x || is_nan1.x || is_nan2.x, comparison.y || is_nan1.y || is_nan2.y);
}}
const float fswzadd_modifiers_a[] = float[4](-1.0f, 1.0f, -1.0f, 0.0f );
const float fswzadd_modifiers_b[] = float[4](-1.0f, -1.0f, 1.0f, -1.0f );
layout (std140, binding = {}) uniform vs_config {{
float y_direction;
}};
)";
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
class ShaderWriter final {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
public:
void AddExpression(std::string_view text) {
DEBUG_ASSERT(scope >= 0);
if (!text.empty()) {
AppendIndentation();
}
shader_source += text;
}
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
// Forwards all arguments directly to libfmt.
gl_shader_decompiler: Add AddLine() overload that forwards to fmt In a lot of places throughout the decompiler, string concatenation via operator+ is used quite heavily. This is usually fine, when not heavily used, but when used extensively, can be a problem. operator+ creates an entirely new heap allocated temporary string and given we perform expressions like: std::string thing = a + b + c + d; this ends up with a lot of unnecessary temporary strings being created and discarded, which kind of thrashes the heap more than we need to. Given we utilize fmt in some AddLine calls, we can make this a part of the ShaderWriter's API. We can make an overload that simply acts as a passthrough to fmt. This way, whenever things need to be appended to a string, the operation can be done via a single string formatting operation instead of discarding numerous temporary strings. This also has the benefit of making the strings themselves look nicer and makes it easier to spot errors in them.
2019-05-14 18:12:57 +02:00
// Note that all formatting requirements for fmt must be
// obeyed when using this function. (e.g. {{ must be used
// printing the character '{' is desirable. Ditto for }} and '}',
// etc).
template <typename... Args>
void AddLine(std::string_view text, Args&&... args) {
AddExpression(fmt::format(text, std::forward<Args>(args)...));
AddNewLine();
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
void AddNewLine() {
DEBUG_ASSERT(scope >= 0);
shader_source += '\n';
}
gl_shader_decompiler: Rename GenerateTemporal() to GenerateTemporary() Temporal generally indicates a relation to time, but this is just creating a temporary, so this isn't really an accurate name for what the function is actually doing.
2019-04-05 01:35:01 +02:00
std::string GenerateTemporary() {
gl_shader_decompiler: Tidy up minor remaining cases of unnecessary std::string concatenation
2019-05-15 00:12:29 +02:00
return fmt::format("tmp{}", temporary_index++);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
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;
gl_shader_decompiler: Rename GenerateTemporal() to GenerateTemporary() Temporal generally indicates a relation to time, but this is just creating a temporary, so this isn't really an accurate name for what the function is actually doing.
2019-04-05 01:35:01 +02:00
u32 temporary_index = 1;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
};
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
class Expression final {
public:
Expression(std::string code, Type type) : code{std::move(code)}, type{type} {
ASSERT(type != Type::Void);
}
Expression() : type{Type::Void} {}
Type GetType() const {
return type;
}
std::string GetCode() const {
return code;
}
void CheckVoid() const {
ASSERT(type == Type::Void);
}
std::string As(Type type) const {
switch (type) {
case Type::Bool:
return AsBool();
case Type::Bool2:
return AsBool2();
case Type::Float:
return AsFloat();
case Type::Int:
return AsInt();
case Type::Uint:
return AsUint();
case Type::HalfFloat:
return AsHalfFloat();
default:
UNREACHABLE_MSG("Invalid type");
return code;
}
}
std::string AsBool() const {
switch (type) {
case Type::Bool:
return code;
default:
UNREACHABLE_MSG("Incompatible types");
return code;
}
}
std::string AsBool2() const {
switch (type) {
case Type::Bool2:
return code;
default:
UNREACHABLE_MSG("Incompatible types");
return code;
}
}
std::string AsFloat() const {
switch (type) {
case Type::Float:
return code;
case Type::Uint:
return fmt::format("utof({})", code);
case Type::Int:
return fmt::format("itof({})", code);
case Type::HalfFloat:
return fmt::format("utof(packHalf2x16({}))", code);
default:
UNREACHABLE_MSG("Incompatible types");
return code;
}
}
std::string AsInt() const {
switch (type) {
case Type::Float:
return fmt::format("ftoi({})", code);
case Type::Uint:
return fmt::format("int({})", code);
case Type::Int:
return code;
case Type::HalfFloat:
return fmt::format("int(packHalf2x16({}))", code);
default:
UNREACHABLE_MSG("Incompatible types");
return code;
}
}
std::string AsUint() const {
switch (type) {
case Type::Float:
return fmt::format("ftou({})", code);
case Type::Uint:
return code;
case Type::Int:
return fmt::format("uint({})", code);
case Type::HalfFloat:
return fmt::format("packHalf2x16({})", code);
default:
UNREACHABLE_MSG("Incompatible types");
return code;
}
}
std::string AsHalfFloat() const {
switch (type) {
case Type::Float:
return fmt::format("unpackHalf2x16(ftou({}))", code);
case Type::Uint:
return fmt::format("unpackHalf2x16({})", code);
case Type::Int:
return fmt::format("unpackHalf2x16(int({}))", code);
case Type::HalfFloat:
return code;
default:
UNREACHABLE_MSG("Incompatible types");
return code;
}
}
private:
std::string code;
Type type{};
};
gl_shader_cache: Specialize shared memory size Shared memory was being declared with an undefined size. Specialize from guest GPU parameters the compute shader's shared memory size.
2019-11-13 03:39:45 +01:00
const char* GetTypeString(Type type) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
switch (type) {
case Type::Bool:
return "bool";
case Type::Bool2:
return "bvec2";
case Type::Float:
return "float";
case Type::Int:
return "int";
case Type::Uint:
return "uint";
case Type::HalfFloat:
return "vec2";
default:
UNREACHABLE_MSG("Invalid type");
return "<invalid type>";
}
}
gl_shader_cache: Specialize shared memory size Shared memory was being declared with an undefined size. Specialize from guest GPU parameters the compute shader's shared memory size.
2019-11-13 03:39:45 +01:00
const char* GetImageTypeDeclaration(Tegra::Shader::ImageType image_type) {
gl_shader_decompiler: Fix clang build issues
2019-09-24 06:03:27 +02:00
switch (image_type) {
case Tegra::Shader::ImageType::Texture1D:
return "1D";
case Tegra::Shader::ImageType::TextureBuffer:
return "Buffer";
case Tegra::Shader::ImageType::Texture1DArray:
return "1DArray";
case Tegra::Shader::ImageType::Texture2D:
return "2D";
case Tegra::Shader::ImageType::Texture2DArray:
return "2DArray";
case Tegra::Shader::ImageType::Texture3D:
return "3D";
default:
UNREACHABLE();
return "1D";
}
}
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
/// Describes primitive behavior on geometry shaders
std::pair<const char*, u32> GetPrimitiveDescription(Maxwell::PrimitiveTopology topology) {
switch (topology) {
case Maxwell::PrimitiveTopology::Points:
return {"points", 1};
case Maxwell::PrimitiveTopology::Lines:
case Maxwell::PrimitiveTopology::LineStrip:
return {"lines", 2};
case Maxwell::PrimitiveTopology::LinesAdjacency:
case Maxwell::PrimitiveTopology::LineStripAdjacency:
return {"lines_adjacency", 4};
case Maxwell::PrimitiveTopology::Triangles:
case Maxwell::PrimitiveTopology::TriangleStrip:
case Maxwell::PrimitiveTopology::TriangleFan:
return {"triangles", 3};
case Maxwell::PrimitiveTopology::TrianglesAdjacency:
case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
return {"triangles_adjacency", 6};
default:
UNIMPLEMENTED_MSG("topology={}", static_cast<int>(topology));
return {"points", 1};
}
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
/// Generates code to use for a swizzle operation.
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
constexpr const char* GetSwizzle(std::size_t element) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
constexpr std::array swizzle = {".x", ".y", ".z", ".w"};
gl_shader_decompiler: Make GetSwizzle constexpr
2019-05-03 07:59:25 +02:00
return swizzle.at(element);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
constexpr const char* GetColorSwizzle(std::size_t element) {
constexpr std::array swizzle = {".r", ".g", ".b", ".a"};
return swizzle.at(element);
}
video_core: Implement IR based geometry shaders
2018-12-24 06:24:38 +01:00
/// Translate topology
gl_shader_decompiler: Hide local definitions inside an anonymous namespace
2019-03-31 05:24:10 +02:00
std::string GetTopologyName(Tegra::Shader::OutputTopology topology) {
video_core: Implement IR based geometry shaders
2018-12-24 06:24:38 +01:00
switch (topology) {
case Tegra::Shader::OutputTopology::PointList:
return "points";
case Tegra::Shader::OutputTopology::LineStrip:
return "line_strip";
case Tegra::Shader::OutputTopology::TriangleStrip:
return "triangle_strip";
default:
UNIMPLEMENTED_MSG("Unknown output topology: {}", static_cast<u32>(topology));
return "points";
}
}
/// Returns true if an object has to be treated as precise
gl_shader_decompiler: Hide local definitions inside an anonymous namespace
2019-03-31 05:24:10 +02:00
bool IsPrecise(Operation operand) {
shader_ir/decode: Fix half float pre-operations and remove MetaHalfArithmetic Operations done before the main half float operation (like HAdd) were managing a packed value instead of the unpacked one. Adding an unpacked operation allows us to drop the per-operand MetaHalfArithmetic entry, simplifying the code overall.
2019-04-16 00:48:11 +02:00
const auto& meta{operand.GetMeta()};
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
if (const auto arithmetic = std::get_if<MetaArithmetic>(&meta)) {
return arithmetic->precise;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
return false;
}
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
bool IsPrecise(const Node& node) {
if (const auto operation = std::get_if<OperationNode>(&*node)) {
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
return IsPrecise(*operation);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
return false;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
constexpr bool IsGenericAttribute(Attribute::Index index) {
return index >= Attribute::Index::Attribute_0 && index <= Attribute::Index::Attribute_31;
}
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
constexpr bool IsLegacyTexCoord(Attribute::Index index) {
return static_cast<int>(index) >= static_cast<int>(Attribute::Index::TexCoord_0) &&
static_cast<int>(index) <= static_cast<int>(Attribute::Index::TexCoord_7);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
constexpr Attribute::Index ToGenericAttribute(u64 value) {
return static_cast<Attribute::Index>(value + static_cast<u64>(Attribute::Index::Attribute_0));
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
}
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
constexpr int GetLegacyTexCoordIndex(Attribute::Index index) {
return static_cast<int>(index) - static_cast<int>(Attribute::Index::TexCoord_0);
}
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
u32 GetGenericAttributeIndex(Attribute::Index index) {
ASSERT(IsGenericAttribute(index));
return static_cast<u32>(index) - static_cast<u32>(Attribute::Index::Attribute_0);
}
shader: Split SSY and PBK stack Hardware testing revealed that SSY and PBK push to a different stack, allowing code like this: SSY label1; PBK label2; SYNC; label1: PBK; label2: EXIT;
2019-06-02 23:52:07 +02:00
constexpr const char* GetFlowStackPrefix(MetaStackClass stack) {
switch (stack) {
case MetaStackClass::Ssy:
return "ssy";
case MetaStackClass::Pbk:
return "pbk";
}
return {};
}
std::string FlowStackName(MetaStackClass stack) {
return fmt::format("{}_flow_stack", GetFlowStackPrefix(stack));
}
std::string FlowStackTopName(MetaStackClass stack) {
return fmt::format("{}_flow_stack_top", GetFlowStackPrefix(stack));
}
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
struct GenericVaryingDescription {
std::string name;
u8 first_element = 0;
bool is_scalar = false;
};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
class GLSLDecompiler final {
public:
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
gl_shader_decompiler: Add identifier to decompiled code
2020-02-29 20:30:20 +01:00
ShaderType stage, std::string_view identifier, std::string_view suffix)
: device{device}, ir{ir}, registry{registry}, stage{stage},
vk/gl_shader_decompiler: Silence assertion on compute
2020-03-12 07:27:29 +01:00
identifier{identifier}, suffix{suffix}, header{ir.GetHeader()} {
if (stage != ShaderType::Compute) {
transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
}
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
void Decompile() {
DeclareHeader();
DeclareVertex();
DeclareGeometry();
DeclareFragment();
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
DeclareCompute();
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
DeclareInputAttributes();
DeclareOutputAttributes();
DeclareImages();
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
DeclareSamplers();
DeclareGlobalMemory();
DeclareConstantBuffers();
DeclareLocalMemory();
DeclareRegisters();
DeclarePredicates();
DeclareInternalFlags();
DeclareCustomVariables();
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
DeclarePhysicalAttributeReader();
code.AddLine("void main() {{");
++code.scope;
gl_shader_decompiler: Initialize gl_Position on vertex shaders
2020-03-13 03:31:06 +01:00
if (stage == ShaderType::Vertex) {
code.AddLine("gl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);");
}
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
if (ir.IsDecompiled()) {
DecompileAST();
} else {
DecompileBranchMode();
}
--code.scope;
code.AddLine("}}");
}
std::string GetResult() {
return code.GetResult();
}
private:
friend class ASTDecompiler;
friend class ExprDecompiler;
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
void DecompileBranchMode() {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// VM's program counter
const auto first_address = ir.GetBasicBlocks().begin()->first;
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("uint jmp_to = {}U;", first_address);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// 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.
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
constexpr u32 FLOW_STACK_SIZE = 20;
Shader_Ir: Refactor Decompilation process and allow multiple decompilation modes.
2019-08-16 22:25:02 +02:00
if (!ir.IsFlowStackDisabled()) {
for (const auto stack : std::array{MetaStackClass::Ssy, MetaStackClass::Pbk}) {
code.AddLine("uint {}[{}];", FlowStackName(stack), FLOW_STACK_SIZE);
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
code.AddLine("uint {} = 0U;", FlowStackTopName(stack));
Shader_Ir: Refactor Decompilation process and allow multiple decompilation modes.
2019-08-16 22:25:02 +02:00
}
shader: Split SSY and PBK stack Hardware testing revealed that SSY and PBK push to a different stack, allowing code like this: SSY label1; PBK label2; SYNC; label1: PBK; label2: EXIT;
2019-06-02 23:52:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("while (true) {{");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
++code.scope;
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("switch (jmp_to) {{");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
for (const auto& pair : ir.GetBasicBlocks()) {
gl_shader_decompiler: Avoid copies where applicable Avoids unnecessary reference count increments where applicable and also avoids reallocating a vector. Unlikely to make a huge difference, but given how trivial of an amendment it is, why not?
2020-04-18 02:47:00 +02:00
const auto& [address, bb] = pair;
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("case 0x{:X}U: {{", address);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
++code.scope;
shader_ir: Rename BasicBlock to NodeBlock It's not always used as a basic block. Rename it for consistency.
2019-01-30 06:09:40 +01:00
VisitBlock(bb);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
--code.scope;
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("}}");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
code.AddLine("default: return;");
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("}}");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
--code.scope;
code.AddLine("}}");
}
void DecompileAST();
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
void DeclareHeader() {
gl_shader_decompiler: Add identifier to decompiled code
2020-02-29 20:30:20 +01:00
if (!identifier.empty()) {
code.AddLine("// {}", identifier);
}
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
code.AddLine("#version 440 {}", ir.UsesLegacyVaryings() ? "compatibility" : "core");
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
code.AddLine("#extension GL_ARB_separate_shader_objects : enable");
if (device.HasShaderBallot()) {
code.AddLine("#extension GL_ARB_shader_ballot : require");
}
if (device.HasVertexViewportLayer()) {
code.AddLine("#extension GL_ARB_shader_viewport_layer_array : require");
}
if (device.HasImageLoadFormatted()) {
code.AddLine("#extension GL_EXT_shader_image_load_formatted : require");
}
if (device.HasWarpIntrinsics()) {
code.AddLine("#extension GL_NV_gpu_shader5 : require");
code.AddLine("#extension GL_NV_shader_thread_group : require");
code.AddLine("#extension GL_NV_shader_thread_shuffle : require");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
// This pragma stops Nvidia's driver from over optimizing math (probably using fp16
// operations) on places where we don't want to.
// Thanks to Ryujinx for finding this workaround.
code.AddLine("#pragma optionNV(fastmath off)");
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
code.AddNewLine();
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
code.AddLine(CommonDeclarations, EmulationUniformBlockBinding);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
void DeclareVertex() {
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
if (stage != ShaderType::Vertex) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return;
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
glsl_decompiler: Fixup geometry shaders
2018-12-25 01:28:44 +01:00
DeclareVertexRedeclarations();
}
void DeclareGeometry() {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage != ShaderType::Geometry) {
glsl_decompiler: Fixup geometry shaders
2018-12-25 01:28:44 +01:00
return;
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Fixup geometry shaders
2018-12-25 01:28:44 +01:00
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
const auto& info = registry.GetGraphicsInfo();
const auto input_topology = info.primitive_topology;
const auto [glsl_topology, max_vertices] = GetPrimitiveDescription(input_topology);
max_input_vertices = max_vertices;
code.AddLine("layout ({}) in;", glsl_topology);
glsl_decompiler: Fixup geometry shaders
2018-12-25 01:28:44 +01:00
const auto topology = GetTopologyName(header.common3.output_topology);
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
const auto max_output_vertices = header.common4.max_output_vertices.Value();
code.AddLine("layout ({}, max_vertices = {}) out;", topology, max_output_vertices);
glsl_decompiler: Fixup geometry shaders
2018-12-25 01:28:44 +01:00
code.AddNewLine();
gl_shader_decompiler: Remove guest "position" varying "position" was being written but not read anywhere besides geometry shaders, where it had the same value as gl_Position. This commit replaces "position" with gl_Position, reducing the complexity of our code and the emitted GLSL code.
2019-06-03 06:01:34 +02:00
code.AddLine("in gl_PerVertex {{");
++code.scope;
code.AddLine("vec4 gl_Position;");
--code.scope;
code.AddLine("}} gl_in[];");
glsl_decompiler: Fixup geometry shaders
2018-12-25 01:28:44 +01:00
DeclareVertexRedeclarations();
}
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
void DeclareFragment() {
if (stage != ShaderType::Fragment) {
return;
}
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
if (ir.UsesLegacyVaryings()) {
code.AddLine("in gl_PerFragment {{");
++code.scope;
code.AddLine("vec4 gl_TexCoord[8];");
code.AddLine("vec4 gl_Color;");
code.AddLine("vec4 gl_SecondaryColor;");
--code.scope;
code.AddLine("}};");
}
gl_shader_decompiler: Fix regression in render target declarations A previous commit introduced a way to declare as few render targets as possible. Turns out this introduced a regression in some games.
2020-03-12 08:28:50 +01:00
for (u32 rt = 0; rt < Maxwell::NumRenderTargets; ++rt) {
code.AddLine("layout (location = {}) out vec4 frag_color{};", rt, rt);
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
}
}
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
void DeclareCompute() {
if (stage != ShaderType::Compute) {
return;
}
const auto& info = registry.GetComputeInfo();
if (const u32 size = info.shared_memory_size_in_words; size > 0) {
gl_shader_decompiler: Add missing {} on smem GLSL emission
2020-03-13 01:50:37 +01:00
code.AddLine("shared uint smem[{}];", size);
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
code.AddNewLine();
}
code.AddLine("layout (local_size_x = {}, local_size_y = {}, local_size_z = {}) in;",
info.workgroup_size[0], info.workgroup_size[1], info.workgroup_size[2]);
code.AddNewLine();
}
glsl_decompiler: Fixup geometry shaders
2018-12-25 01:28:44 +01:00
void DeclareVertexRedeclarations() {
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("out gl_PerVertex {{");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
++code.scope;
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
auto pos_xfb = GetTransformFeedbackDecoration(Attribute::Index::Position);
if (!pos_xfb.empty()) {
pos_xfb = fmt::format("layout ({}) ", pos_xfb);
}
const char* pos_type =
FLOAT_TYPES.at(GetNumComponents(Attribute::Index::Position).value_or(4) - 1);
code.AddLine("{}{} gl_Position;", pos_xfb, pos_type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
for (const auto attribute : ir.GetOutputAttributes()) {
if (attribute == Attribute::Index::ClipDistances0123 ||
attribute == Attribute::Index::ClipDistances4567) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddLine("float gl_ClipDistance[];");
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
break;
}
}
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
if (stage != ShaderType::Vertex || device.HasVertexViewportLayer()) {
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
if (ir.UsesLayer()) {
code.AddLine("int gl_Layer;");
}
if (ir.UsesViewportIndex()) {
code.AddLine("int gl_ViewportIndex;");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
} else if ((ir.UsesLayer() || ir.UsesViewportIndex()) && stage == ShaderType::Vertex &&
gl_shader_decompiler: Fix conditional usage of GL_ARB_shader_viewport_layer_array
2019-07-11 09:24:57 +02:00
!device.HasVertexViewportLayer()) {
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
LOG_ERROR(
Render_OpenGL,
"GL_ARB_shader_viewport_layer_array is not available and its required by a shader");
}
if (ir.UsesPointSize()) {
gl_shader_decompiler: Fix gl_PointSize redeclaration
2019-07-11 21:10:59 +02:00
code.AddLine("float gl_PointSize;");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
if (ir.UsesLegacyVaryings()) {
code.AddLine("vec4 gl_TexCoord[8];");
code.AddLine("vec4 gl_FrontColor;");
code.AddLine("vec4 gl_FrontSecondaryColor;");
code.AddLine("vec4 gl_BackColor;");
code.AddLine("vec4 gl_BackSecondaryColor;");
VideoCore: Corrections to the MME Inliner and removal of hacky instance management.
2019-09-15 20:25:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
--code.scope;
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("}};");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddNewLine();
}
void DeclareRegisters() {
const auto& registers = ir.GetRegisters();
for (const u32 gpr : registers) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("float {} = 0.0f;", GetRegister(gpr));
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
if (!registers.empty()) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddNewLine();
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
void DeclareCustomVariables() {
Shader_IR: Address feedback.
2020-01-24 15:44:34 +01:00
const u32 num_custom_variables = ir.GetNumCustomVariables();
for (u32 i = 0; i < num_custom_variables; ++i) {
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
code.AddLine("float {} = 0.0f;", GetCustomVariable(i));
}
Shader_IR: Address feedback.
2020-01-24 15:44:34 +01:00
if (num_custom_variables > 0) {
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
code.AddNewLine();
}
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
void DeclarePredicates() {
const auto& predicates = ir.GetPredicates();
for (const auto pred : predicates) {
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
code.AddLine("bool {} = false;", GetPredicate(pred));
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
if (!predicates.empty()) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddNewLine();
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
void DeclareLocalMemory() {
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
u64 local_memory_size = 0;
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage == ShaderType::Compute) {
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
local_memory_size = registry.GetComputeInfo().local_memory_size_in_words * 4ULL;
} else {
local_memory_size = header.GetLocalMemorySize();
gl_shader_cache: Specialize local memory size for compute shaders Local memory size in compute shaders was stubbed with an arbitary size. This commit specializes local memory size from guest GPU parameters.
2019-11-13 04:25:52 +01:00
}
gl_shader_decompiler: Stub local memory size
2019-07-15 22:28:27 +02:00
if (local_memory_size == 0) {
gl_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
return;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
const u64 element_count = Common::AlignUp(local_memory_size, 4) / 4;
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("uint {}[{}];", GetLocalMemory(), element_count);
gl_shader_decompiler: Stub local memory size
2019-07-15 22:28:27 +02:00
code.AddNewLine();
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
void DeclareInternalFlags() {
for (u32 flag = 0; flag < static_cast<u32>(InternalFlag::Amount); flag++) {
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
const auto flag_code = static_cast<InternalFlag>(flag);
code.AddLine("bool {} = false;", GetInternalFlag(flag_code));
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
code.AddNewLine();
}
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
const char* GetInputFlags(PixelImap attribute) {
shader_decompiler: Improve Accuracy of Attribute Interpolation.
2019-02-13 02:14:39 +01:00
switch (attribute) {
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
case PixelImap::Perspective:
return "smooth";
case PixelImap::Constant:
return "flat";
case PixelImap::ScreenLinear:
return "noperspective";
case PixelImap::Unused:
break;
}
UNIMPLEMENTED_MSG("Unknown attribute usage index={}", static_cast<int>(attribute));
return {};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
void DeclareInputAttributes() {
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
if (ir.HasPhysicalAttributes()) {
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
const u32 num_inputs{GetNumPhysicalInputAttributes()};
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
for (u32 i = 0; i < num_inputs; ++i) {
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
DeclareInputAttribute(ToGenericAttribute(i), true);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
code.AddNewLine();
return;
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const auto& attributes = ir.GetInputAttributes();
shader: Remove unused AbufNode Ipa mode
2019-04-30 04:37:09 +02:00
for (const auto index : attributes) {
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
if (IsGenericAttribute(index)) {
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
DeclareInputAttribute(index, false);
shader_decompiler: Improve Accuracy of Attribute Interpolation.
2019-02-13 02:14:39 +01:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
if (!attributes.empty()) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddNewLine();
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
void DeclareInputAttribute(Attribute::Index index, bool skip_unused) {
gl_shader_decompiler: Remove guest "position" varying "position" was being written but not read anywhere besides geometry shaders, where it had the same value as gl_Position. This commit replaces "position" with gl_Position, reducing the complexity of our code and the emitted GLSL code.
2019-06-03 06:01:34 +02:00
const u32 location{GetGenericAttributeIndex(index)};
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
std::string name{GetGenericInputAttribute(index)};
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage == ShaderType::Geometry) {
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
name = "gs_" + name + "[]";
}
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
std::string suffix;
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage == ShaderType::Fragment) {
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
const auto input_mode{header.ps.GetPixelImap(location)};
if (input_mode == PixelImap::Unused) {
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
return;
}
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
suffix = GetInputFlags(input_mode);
}
renderer_opengl/gl_shader_decompiler: Remove redundant name specification in format string This accidentally slipped through a rebase.
2019-05-21 15:45:39 +02:00
code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix, name);
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
void DeclareOutputAttributes() {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (ir.HasPhysicalAttributes() && stage != ShaderType::Fragment) {
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
for (u32 i = 0; i < GetNumPhysicalVaryings(); ++i) {
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
DeclareOutputAttribute(ToGenericAttribute(i));
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
}
code.AddNewLine();
return;
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const auto& attributes = ir.GetOutputAttributes();
for (const auto index : attributes) {
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
if (IsGenericAttribute(index)) {
DeclareOutputAttribute(index);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
}
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
if (!attributes.empty()) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddNewLine();
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
std::optional<std::size_t> GetNumComponents(Attribute::Index index, u8 element = 0) const {
gl_shader_decompiler: Fix implicit conversion errors
2020-03-10 00:46:16 +01:00
const u8 location = static_cast<u8>(static_cast<u32>(index) * 4 + element);
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
const auto it = transform_feedback.find(location);
if (it == transform_feedback.end()) {
return {};
}
return it->second.components;
}
std::string GetTransformFeedbackDecoration(Attribute::Index index, u8 element = 0) const {
gl_shader_decompiler: Fix implicit conversion errors
2020-03-10 00:46:16 +01:00
const u8 location = static_cast<u8>(static_cast<u32>(index) * 4 + element);
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
const auto it = transform_feedback.find(location);
if (it == transform_feedback.end()) {
return {};
}
const VaryingTFB& tfb = it->second;
shader/transform_feedback: Expose buffer stride
2020-03-06 09:03:13 +01:00
return fmt::format("xfb_buffer = {}, xfb_offset = {}, xfb_stride = {}", tfb.buffer,
tfb.offset, tfb.stride);
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
}
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
void DeclareOutputAttribute(Attribute::Index index) {
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
static constexpr std::string_view swizzle = "xyzw";
u8 element = 0;
while (element < 4) {
auto xfb = GetTransformFeedbackDecoration(index, element);
if (!xfb.empty()) {
xfb = fmt::format(", {}", xfb);
}
const std::size_t remainder = 4 - element;
const std::size_t num_components = GetNumComponents(index, element).value_or(remainder);
const char* const type = FLOAT_TYPES.at(num_components - 1);
const u32 location = GetGenericAttributeIndex(index);
GenericVaryingDescription description;
description.first_element = static_cast<u8>(element);
description.is_scalar = num_components == 1;
description.name = AppendSuffix(location, OUTPUT_ATTRIBUTE_NAME);
if (element != 0 || num_components != 4) {
const std::string_view name_swizzle = swizzle.substr(element, num_components);
description.name = fmt::format("{}_{}", description.name, name_swizzle);
}
for (std::size_t i = 0; i < num_components; ++i) {
const u8 offset = static_cast<u8>(location * 4 + element + i);
varying_description.insert({offset, description});
}
code.AddLine("layout (location = {}, component = {}{}) out {} {};", location, element,
xfb, type, description.name);
gl_shader_decompiler: Fix implicit conversion errors
2020-03-10 00:46:16 +01:00
element = static_cast<u8>(static_cast<std::size_t>(element) + num_components);
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
}
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
void DeclareConstantBuffers() {
gl_shader_decompiler: Normalize cbuf bindings Stage and compute shaders were using a different binding counter. Normalize these.
2019-11-21 18:21:42 +01:00
u32 binding = device.GetBaseBindings(stage).uniform_buffer;
CMakeLists: Specify -Wextra on linux builds Allows reporting more cases where logic errors may exist, such as implicit fallthrough cases, etc. We currently ignore unused parameters, since we currently have many cases where this is intentional (virtual interfaces). While we're at it, we can also tidy up any existing code that causes warnings. This also uncovered a few bugs as well.
2020-04-15 21:59:23 +02:00
for (const auto& buffers : ir.GetConstantBuffers()) {
const auto index = buffers.first;
gl_shader_decompiler: Normalize cbuf bindings Stage and compute shaders were using a different binding counter. Normalize these.
2019-11-21 18:21:42 +01:00
code.AddLine("layout (std140, binding = {}) uniform {} {{", binding++,
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
GetConstBufferBlock(index));
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine(" uvec4 {}[{}];", GetConstBuffer(index), MAX_CONSTBUFFER_ELEMENTS);
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("}};");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddNewLine();
}
}
shader_decode: Implement LDG and basic cbuf tracking
2018-12-29 06:44:54 +01:00
void DeclareGlobalMemory() {
gl_shader_cache: Remove dynamic BaseBinding specialization
2019-11-19 01:38:15 +01:00
u32 binding = device.GetBaseBindings(stage).shader_storage_buffer;
gl_shader_decompiler: Normalize cbuf bindings Stage and compute shaders were using a different binding counter. Normalize these.
2019-11-21 18:21:42 +01:00
for (const auto& [base, usage] : ir.GetGlobalMemory()) {
shader_ir: Implement STG, keep track of global memory usage and flush
2019-02-07 04:05:41 +01:00
// Since we don't know how the shader will use the shader, hint the driver to disable as
// much optimizations as possible
std::string qualifier = "coherent volatile";
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
if (usage.is_read && !usage.is_written) {
shader_ir: Implement STG, keep track of global memory usage and flush
2019-02-07 04:05:41 +01:00
qualifier += " readonly";
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
} else if (usage.is_written && !usage.is_read) {
shader_ir: Implement STG, keep track of global memory usage and flush
2019-02-07 04:05:41 +01:00
qualifier += " writeonly";
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
shader_ir: Implement STG, keep track of global memory usage and flush
2019-02-07 04:05:41 +01:00
gl_shader_cache: Remove dynamic BaseBinding specialization
2019-11-19 01:38:15 +01:00
code.AddLine("layout (std430, binding = {}) {} buffer {} {{", binding++, qualifier,
GetGlobalMemoryBlock(base));
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine(" uint {}[];", GetGlobalMemory(base));
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("}};");
shader_decode: Implement LDG and basic cbuf tracking
2018-12-29 06:44:54 +01:00
code.AddNewLine();
}
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
void DeclareSamplers() {
gl_shader_decompiler: Normalize image bindings
2019-11-22 08:34:14 +01:00
u32 binding = device.GetBaseBindings(stage).sampler;
for (const auto& sampler : ir.GetSamplers()) {
gl_shader_cache: Remove dynamic BaseBinding specialization
2019-11-19 01:38:15 +01:00
const std::string name = GetSampler(sampler);
GL Backend: Introduce indexed samplers into the GL backend
2020-01-06 16:43:13 +01:00
const std::string description = fmt::format("layout (binding = {}) uniform", binding);
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
binding += sampler.is_indexed ? sampler.size : 1;
gl_shader_cache: Remove dynamic BaseBinding specialization
2019-11-19 01:38:15 +01:00
gl_shader_decompiler: Allow 1D textures to be texture buffers
2019-04-28 02:45:59 +02:00
std::string sampler_type = [&]() {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (sampler.is_buffer) {
shader/texture: Deduce texture buffers from locker Instead of specializing shaders to separate texture buffers from 1D textures, use the locker to deduce them while they are being decoded.
2019-11-06 08:32:43 +01:00
return "samplerBuffer";
}
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
switch (sampler.type) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
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();
video_core: Return safe values after an assert hits
2018-12-21 22:47:22 +01:00
return "sampler2D";
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
}();
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (sampler.is_array) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
sampler_type += "Array";
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (sampler.is_shadow) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
sampler_type += "Shadow";
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (!sampler.is_indexed) {
GL Backend: Introduce indexed samplers into the GL backend
2020-01-06 16:43:13 +01:00
code.AddLine("{} {} {};", description, sampler_type, name);
} else {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
code.AddLine("{} {} {}[{}];", description, sampler_type, name, sampler.size);
GL Backend: Introduce indexed samplers into the GL backend
2020-01-06 16:43:13 +01:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Normalize image bindings
2019-11-22 08:34:14 +01:00
if (!ir.GetSamplers().empty()) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddNewLine();
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
void DeclarePhysicalAttributeReader() {
if (!ir.HasPhysicalAttributes()) {
return;
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("float ReadPhysicalAttribute(uint physical_address) {{");
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
++code.scope;
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
code.AddLine("switch (physical_address) {{");
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
// Just declare generic attributes for now.
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
const auto num_attributes{static_cast<u32>(GetNumPhysicalInputAttributes())};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
for (u32 index = 0; index < num_attributes; ++index) {
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
const auto attribute{ToGenericAttribute(index)};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
for (u32 element = 0; element < 4; ++element) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
constexpr u32 generic_base = 0x80;
constexpr u32 generic_stride = 16;
constexpr u32 element_stride = 4;
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
const u32 address{generic_base + index * generic_stride + element * element_stride};
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
const bool declared = stage != ShaderType::Fragment ||
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
header.ps.GetPixelImap(index) != PixelImap::Unused;
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
const std::string value =
declared ? ReadAttribute(attribute, element).AsFloat() : "0.0f";
code.AddLine("case 0x{:X}U: return {};", address, value);
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
}
code.AddLine("default: return 0;");
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
code.AddLine("}}");
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
--code.scope;
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
code.AddLine("}}");
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
code.AddNewLine();
}
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
void DeclareImages() {
gl_shader_decompiler: Normalize image bindings
2019-11-22 08:34:14 +01:00
u32 binding = device.GetBaseBindings(stage).image;
for (const auto& image : ir.GetImages()) {
gl_shader_decompiler: Keep track of written images and mark them as modified
2019-09-06 04:26:05 +02:00
std::string qualifier = "coherent volatile";
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (image.is_read && !image.is_written) {
gl_shader_decompiler: Keep track of written images and mark them as modified
2019-09-06 04:26:05 +02:00
qualifier += " readonly";
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
} else if (image.is_written && !image.is_read) {
gl_shader_decompiler: Keep track of written images and mark them as modified
2019-09-06 04:26:05 +02:00
qualifier += " writeonly";
}
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const char* format = image.is_atomic ? "r32ui, " : "";
const char* type_declaration = GetImageTypeDeclaration(image.type);
gl_shader_decompiler: Normalize image bindings
2019-11-22 08:34:14 +01:00
code.AddLine("layout ({}binding = {}) {} uniform uimage{} {};", format, binding++,
gl_shader_cache: Remove dynamic BaseBinding specialization
2019-11-19 01:38:15 +01:00
qualifier, type_declaration, GetImage(image));
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
}
gl_shader_decompiler: Normalize image bindings
2019-11-22 08:34:14 +01:00
if (!ir.GetImages().empty()) {
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
code.AddNewLine();
gl_shader_decompiler: Address feedback
2019-06-24 06:56:38 +02:00
}
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
}
shader_ir: Rename BasicBlock to NodeBlock It's not always used as a basic block. Rename it for consistency.
2019-01-30 06:09:40 +01:00
void VisitBlock(const NodeBlock& bb) {
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
for (const auto& node : bb) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Visit(node).CheckVoid();
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Visit(const Node& node) {
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto operation = std::get_if<OperationNode>(&*node)) {
Shader_IR: Address Feedback
2020-01-04 19:40:57 +01:00
if (const auto amend_index = operation->GetAmendIndex()) {
Visit(ir.GetAmendNode(*amend_index)).CheckVoid();
Shader_IR: add the ability to amend code in the shader ir. This commit introduces a mechanism by which shader IR code can be amended and extended. This useful for track algorithms where certain information can derived from before the track such as indexes to array samplers.
2019-12-30 18:54:53 +01:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const auto operation_index = static_cast<std::size_t>(operation->GetCode());
gl_shader_decompiler: Return early when an operation is invalid
2019-04-03 21:01:53 +02:00
if (operation_index >= operation_decompilers.size()) {
UNREACHABLE_MSG("Out of bounds operation: {}", operation_index);
return {};
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const auto decompiler = operation_decompilers[operation_index];
if (decompiler == nullptr) {
gl_shader_decompiler: Return early when an operation is invalid
2019-04-03 21:01:53 +02:00
UNREACHABLE_MSG("Undefined operation: {}", operation_index);
return {};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
return (this->*decompiler)(*operation);
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto gpr = std::get_if<GprNode>(&*node)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const u32 index = gpr->GetIndex();
shader_ir: Remove RZ and use Register::ZeroIndex instead
2018-12-26 05:49:32 +01:00
if (index == Register::ZeroIndex) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0U", Type::Uint};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {GetRegister(index), Type::Float};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
if (const auto cv = std::get_if<CustomVarNode>(&*node)) {
const u32 index = cv->GetIndex();
return {GetCustomVariable(index), Type::Float};
}
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto immediate = std::get_if<ImmediateNode>(&*node)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const u32 value = immediate->GetValue();
if (value < 10) {
// For eyecandy avoid using hex numbers on single digits
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("{}U", immediate->GetValue()), Type::Uint};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("0x{:X}U", immediate->GetValue()), Type::Uint};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto predicate = std::get_if<PredicateNode>(&*node)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
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()) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("!({})", value), Type::Bool};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {value, Type::Bool};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto abuf = std::get_if<AbufNode>(&*node)) {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
UNIMPLEMENTED_IF_MSG(abuf->IsPhysicalBuffer() && stage == ShaderType::Geometry,
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
"Physical attributes in geometry shaders are not implemented");
if (abuf->IsPhysicalBuffer()) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("ReadPhysicalAttribute({})",
Visit(abuf->GetPhysicalAddress()).AsUint()),
Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
return ReadAttribute(abuf->GetIndex(), abuf->GetElement(), abuf->GetBuffer());
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto cbuf = std::get_if<CbufNode>(&*node)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const Node offset = cbuf->GetOffset();
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto immediate = std::get_if<ImmediateNode>(&*offset)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// Direct access
const u32 offset_imm = immediate->GetValue();
shader_ir: Unify constant buffer offset values Constant buffer values on the shader IR were using different offsets if the access direct or indirect. cbuf34 has a non-multiplied offset while cbuf36 does. On shader decoding this commit multiplies it by four on cbuf34 queries.
2019-01-28 22:11:23 +01:00
ASSERT_MSG(offset_imm % 4 == 0, "Unaligned cbuf direct access");
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("{}[{}][{}]", GetConstBuffer(cbuf->GetIndex()),
offset_imm / (4 * 4), (offset_imm / 4) % 4),
Type::Uint};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
if (std::holds_alternative<OperationNode>(*offset)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// Indirect access
gl_shader_decompiler: Rename GenerateTemporal() to GenerateTemporary() Temporal generally indicates a relation to time, but this is just creating a temporary, so this isn't really an accurate name for what the function is actually doing.
2019-04-05 01:35:01 +02:00
const std::string final_offset = code.GenerateTemporary();
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("uint {} = {} >> 2;", final_offset, Visit(offset).AsUint());
gl_shader_decompiler: Use an if based cbuf indexing for broken drivers The following code is broken on AMD's proprietary GLSL compiler: ```glsl uint idx = ...; vec4 values = ...; float some_value = values[idx & 3]; ``` It index the wrong components, to fix this the following pessimized code is emitted when that bug is present: ```glsl uint idx = ...; vec4 values = ...; float some_value; if ((idx & 3) == 0) some_value = values.x; if ((idx & 3) == 1) some_value = values.y; if ((idx & 3) == 2) some_value = values.z; if ((idx & 3) == 3) some_value = values.w; ```
2019-05-24 01:27:54 +02:00
if (!device.HasComponentIndexingBug()) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("{}[{} >> 2][{} & 3]", GetConstBuffer(cbuf->GetIndex()),
final_offset, final_offset),
Type::Uint};
gl_shader_decompiler: Use an if based cbuf indexing for broken drivers The following code is broken on AMD's proprietary GLSL compiler: ```glsl uint idx = ...; vec4 values = ...; float some_value = values[idx & 3]; ``` It index the wrong components, to fix this the following pessimized code is emitted when that bug is present: ```glsl uint idx = ...; vec4 values = ...; float some_value; if ((idx & 3) == 0) some_value = values.x; if ((idx & 3) == 1) some_value = values.y; if ((idx & 3) == 2) some_value = values.z; if ((idx & 3) == 3) some_value = values.w; ```
2019-05-24 01:27:54 +02:00
}
// AMD's proprietary GLSL compiler emits ill code for variable component access.
// To bypass this driver bug generate 4 ifs, one per each component.
const std::string pack = code.GenerateTemporary();
gl_shader_decompiler: Fixup slow path
2019-09-04 20:03:51 +02:00
code.AddLine("uvec4 {} = {}[{} >> 2];", pack, GetConstBuffer(cbuf->GetIndex()),
gl_shader_decompiler: Use an if based cbuf indexing for broken drivers The following code is broken on AMD's proprietary GLSL compiler: ```glsl uint idx = ...; vec4 values = ...; float some_value = values[idx & 3]; ``` It index the wrong components, to fix this the following pessimized code is emitted when that bug is present: ```glsl uint idx = ...; vec4 values = ...; float some_value; if ((idx & 3) == 0) some_value = values.x; if ((idx & 3) == 1) some_value = values.y; if ((idx & 3) == 2) some_value = values.z; if ((idx & 3) == 3) some_value = values.w; ```
2019-05-24 01:27:54 +02:00
final_offset);
const std::string result = code.GenerateTemporary();
gl_shader_decompiler: Fixup AMD's slow path type
2019-08-30 23:32:17 +02:00
code.AddLine("uint {};", result);
gl_shader_decompiler: Use an if based cbuf indexing for broken drivers The following code is broken on AMD's proprietary GLSL compiler: ```glsl uint idx = ...; vec4 values = ...; float some_value = values[idx & 3]; ``` It index the wrong components, to fix this the following pessimized code is emitted when that bug is present: ```glsl uint idx = ...; vec4 values = ...; float some_value; if ((idx & 3) == 0) some_value = values.x; if ((idx & 3) == 1) some_value = values.y; if ((idx & 3) == 2) some_value = values.z; if ((idx & 3) == 3) some_value = values.w; ```
2019-05-24 01:27:54 +02:00
for (u32 swizzle = 0; swizzle < 4; ++swizzle) {
code.AddLine("if (({} & 3) == {}) {} = {}{};", final_offset, swizzle, result,
pack, GetSwizzle(swizzle));
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {result, Type::Uint};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
UNREACHABLE_MSG("Unmanaged offset node type");
}
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto gmem = std::get_if<GmemNode>(&*node)) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
const std::string real = Visit(gmem->GetRealAddress()).AsUint();
const std::string base = Visit(gmem->GetBaseAddress()).AsUint();
const std::string final_offset = fmt::format("({} - {}) >> 2", real, base);
return {fmt::format("{}[{}]", GetGlobalMemory(gmem->GetDescriptor()), final_offset),
Type::Uint};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
shader_decode: Implement LDG and basic cbuf tracking
2018-12-29 06:44:54 +01:00
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto lmem = std::get_if<LmemNode>(&*node)) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {
fmt::format("{}[{} >> 2]", GetLocalMemory(), Visit(lmem->GetAddress()).AsUint()),
Type::Uint};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Implement shared memory
2019-08-29 22:18:04 +02:00
if (const auto smem = std::get_if<SmemNode>(&*node)) {
gl_shader_cache: Specialize shared memory size Shared memory was being declared with an undefined size. Specialize from guest GPU parameters the compute shader's shared memory size.
2019-11-13 03:39:45 +01:00
return {fmt::format("smem[{} >> 2]", Visit(smem->GetAddress()).AsUint()), Type::Uint};
gl_shader_decompiler: Implement shared memory
2019-08-29 22:18:04 +02:00
}
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto internal_flag = std::get_if<InternalFlagNode>(&*node)) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {GetInternalFlag(internal_flag->GetFlag()), Type::Bool};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto conditional = std::get_if<ConditionalNode>(&*node)) {
Shader_IR: Address Feedback
2020-01-04 19:40:57 +01:00
if (const auto amend_index = conditional->GetAmendIndex()) {
Visit(ir.GetAmendNode(*amend_index)).CheckVoid();
Shader_IR: add the ability to amend code in the shader ir. This commit introduces a mechanism by which shader IR code can be amended and extended. This useful for track algorithms where certain information can derived from before the track such as indexes to array samplers.
2019-12-30 18:54:53 +01:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// It's invalid to call conditional on nested nodes, use an operation instead
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("if ({}) {{", Visit(conditional->GetCondition()).AsBool());
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
++code.scope;
shader_ir: Rename BasicBlock to NodeBlock It's not always used as a basic block. Rename it for consistency.
2019-01-30 06:09:40 +01:00
VisitBlock(conditional->GetCode());
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
--code.scope;
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("}}");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return {};
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto comment = std::get_if<CommentNode>(&*node)) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("// " + comment->GetText());
return {};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
UNREACHABLE();
video_core: Return safe values after an assert hits
2018-12-21 22:47:22 +01:00
return {};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression ReadAttribute(Attribute::Index attribute, u32 element, const Node& buffer = {}) {
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
const auto GeometryPass = [&](std::string_view name) {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage == ShaderType::Geometry && buffer) {
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
// TODO(Rodrigo): Guard geometry inputs against out of bound reads. Some games
// set an 0x80000000 index for those and the shader fails to build. Find out why
// this happens and what's its intent.
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
return fmt::format("gs_{}[{} % {}]", name, Visit(buffer).AsUint(),
max_input_vertices.value());
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
return std::string(name);
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
};
switch (attribute) {
case Attribute::Index::Position:
gl_shader_decompiler: Remove guest "position" varying "position" was being written but not read anywhere besides geometry shaders, where it had the same value as gl_Position. This commit replaces "position" with gl_Position, reducing the complexity of our code and the emitted GLSL code.
2019-06-03 06:01:34 +02:00
switch (stage) {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
case ShaderType::Geometry:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("gl_in[{}].gl_Position{}", Visit(buffer).AsUint(),
GetSwizzle(element)),
Type::Float};
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
case ShaderType::Fragment:
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
return {"gl_FragCoord"s + GetSwizzle(element), Type::Float};
gl_shader_decompiler: Remove guest "position" varying "position" was being written but not read anywhere besides geometry shaders, where it had the same value as gl_Position. This commit replaces "position" with gl_Position, reducing the complexity of our code and the emitted GLSL code.
2019-06-03 06:01:34 +02:00
default:
UNREACHABLE();
video_core: gl_shader_decompiler: Fix implicit fallthrough errors.
2020-04-18 21:15:21 +02:00
return {"0", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
case Attribute::Index::FrontColor:
return {"gl_Color"s + GetSwizzle(element), Type::Float};
case Attribute::Index::FrontSecondaryColor:
return {"gl_SecondaryColor"s + GetSwizzle(element), Type::Float};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
case Attribute::Index::PointCoord:
switch (element) {
case 0:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"gl_PointCoord.x", Type::Float};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
case 1:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"gl_PointCoord.y", Type::Float};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
case 2:
case 3:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0.0f", Type::Float};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
UNREACHABLE();
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
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.
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
ASSERT(stage == ShaderType::Vertex);
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
switch (element) {
case 2:
// Config pack's first value is instance_id.
VideoCore: Corrections to the MME Inliner and removal of hacky instance management.
2019-09-15 20:25:07 +02:00
return {"gl_InstanceID", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
case 3:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"gl_VertexID", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
UNIMPLEMENTED_MSG("Unmanaged TessCoordInstanceIDVertexID element={}", element);
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
case Attribute::Index::FrontFacing:
// TODO(Subv): Find out what the values are for the other elements.
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
ASSERT(stage == ShaderType::Fragment);
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
switch (element) {
case 3:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"(gl_FrontFacing ? -1 : 0)", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
UNIMPLEMENTED_MSG("Unmanaged FrontFacing element={}", element);
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
default:
if (IsGenericAttribute(attribute)) {
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
return {GeometryPass(GetGenericInputAttribute(attribute)) + GetSwizzle(element),
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Type::Float};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
if (IsLegacyTexCoord(attribute)) {
UNIMPLEMENTED_IF(stage == ShaderType::Geometry);
return {fmt::format("gl_TexCoord[{}]{}", GetLegacyTexCoordIndex(attribute),
GetSwizzle(element)),
Type::Float};
}
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
break;
}
UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0", Type::Int};
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression ApplyPrecise(Operation operation, std::string value, Type type) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
if (!IsPrecise(operation)) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {std::move(value), type};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_device: Disable precise in fragment shaders on bugged drivers
2019-08-31 08:03:35 +02:00
// Old Nvidia drivers have a bug with precise and texture sampling. These are more likely to
// be found in fragment shaders, so we disable precise there. There are vertex shaders that
// also fail to build but nobody seems to care about those.
// Note: Only bugged drivers will skip precise.
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
const bool disable_precise = device.HasPreciseBug() && stage == ShaderType::Fragment;
gl_device: Disable precise in fragment shaders on bugged drivers
2019-08-31 08:03:35 +02:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
std::string temporary = code.GenerateTemporary();
gl_device: Disable precise in fragment shaders on bugged drivers
2019-08-31 08:03:35 +02:00
code.AddLine("{}{} {} = {};", disable_precise ? "" : "precise ", GetTypeString(type),
temporary, value);
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {std::move(temporary), type};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression VisitOperand(Operation operation, std::size_t operand_index) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
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);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression value = Visit(operand);
std::string temporary = code.GenerateTemporary();
code.AddLine("{} {} = {};", GetTypeString(value.GetType()), temporary, value.GetCode());
return {std::move(temporary), value.GetType()};
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
}
gl_shader_decompiler: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
std::optional<Expression> GetOutputAttribute(const AbufNode* abuf) {
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
const u32 element = abuf->GetElement();
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
switch (const auto attribute = abuf->GetIndex()) {
case Attribute::Index::Position:
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
return {{"gl_Position"s + GetSwizzle(element), Type::Float}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
case Attribute::Index::LayerViewportPointSize:
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
switch (element) {
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
case 0:
UNIMPLEMENTED();
return {};
case 1:
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
if (stage == ShaderType::Vertex && !device.HasVertexViewportLayer()) {
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
return {};
}
gl_shader_decompiler: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
return {{"gl_Layer", Type::Int}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
case 2:
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
if (stage == ShaderType::Vertex && !device.HasVertexViewportLayer()) {
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
return {};
}
gl_shader_decompiler: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
return {{"gl_ViewportIndex", Type::Int}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
case 3:
gl_shader_decompiler: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
return {{"gl_PointSize", Type::Float}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
}
return {};
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
case Attribute::Index::FrontColor:
return {{"gl_FrontColor"s + GetSwizzle(element), Type::Float}};
case Attribute::Index::FrontSecondaryColor:
return {{"gl_FrontSecondaryColor"s + GetSwizzle(element), Type::Float}};
case Attribute::Index::BackColor:
return {{"gl_BackColor"s + GetSwizzle(element), Type::Float}};
case Attribute::Index::BackSecondaryColor:
return {{"gl_BackSecondaryColor"s + GetSwizzle(element), Type::Float}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
case Attribute::Index::ClipDistances0123:
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
return {{fmt::format("gl_ClipDistance[{}]", element), Type::Float}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
case Attribute::Index::ClipDistances4567:
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
return {{fmt::format("gl_ClipDistance[{}]", element + 4), Type::Float}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
default:
if (IsGenericAttribute(attribute)) {
gl_shader_decompiler: Implement legacy varyings Legacy varyings are special attributes carried over in hardware from the OpenGL 1 and OpenGL 2 days. These were generally used instead of the generic attributes we use today. They are deprecated or removed from most APIs, but Nvidia still ships them in hardware. To implement these, this commit maps them 1:1 to OpenGL compatibility.
2020-03-16 01:03:54 +01:00
return {{GetGenericOutputAttribute(attribute, element), Type::Float}};
}
if (IsLegacyTexCoord(attribute)) {
return {{fmt::format("gl_TexCoord[{}]{}", GetLegacyTexCoordIndex(attribute),
GetSwizzle(element)),
Type::Float}};
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
}
UNIMPLEMENTED_MSG("Unhandled output attribute: {}", static_cast<u32>(attribute));
return {};
}
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression GenerateUnary(Operation operation, std::string_view func, Type result_type,
Type type_a) {
std::string op_str = fmt::format("{}({})", func, VisitOperand(operation, 0).As(type_a));
return ApplyPrecise(operation, std::move(op_str), result_type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression GenerateBinaryInfix(Operation operation, std::string_view func, Type result_type,
Type type_a, Type type_b) {
const std::string op_a = VisitOperand(operation, 0).As(type_a);
const std::string op_b = VisitOperand(operation, 1).As(type_b);
std::string op_str = fmt::format("({} {} {})", op_a, func, op_b);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return ApplyPrecise(operation, std::move(op_str), result_type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression GenerateBinaryCall(Operation operation, std::string_view func, Type result_type,
Type type_a, Type type_b) {
const std::string op_a = VisitOperand(operation, 0).As(type_a);
const std::string op_b = VisitOperand(operation, 1).As(type_b);
std::string op_str = fmt::format("{}({}, {})", func, op_a, op_b);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return ApplyPrecise(operation, std::move(op_str), result_type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression GenerateTernary(Operation operation, std::string_view func, Type result_type,
Type type_a, Type type_b, Type type_c) {
const std::string op_a = VisitOperand(operation, 0).As(type_a);
const std::string op_b = VisitOperand(operation, 1).As(type_b);
const std::string op_c = VisitOperand(operation, 2).As(type_c);
std::string op_str = fmt::format("{}({}, {}, {})", func, op_a, op_b, op_c);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return ApplyPrecise(operation, std::move(op_str), result_type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression 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).As(type_a);
const std::string op_b = VisitOperand(operation, 1).As(type_b);
const std::string op_c = VisitOperand(operation, 2).As(type_c);
const std::string op_d = VisitOperand(operation, 3).As(type_d);
std::string op_str = fmt::format("{}({}, {}, {}, {})", func, op_a, op_b, op_c, op_d);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return ApplyPrecise(operation, std::move(op_str), result_type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
std::string GenerateTexture(Operation operation, const std::string& function_suffix,
gl_shader_decompiler: Rename "sepparate" to "separate"
2019-12-16 06:12:51 +01:00
const std::vector<TextureIR>& extras, bool separate_dc = false) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
constexpr std::array coord_constructors = {"float", "vec2", "vec3", "vec4"};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
ASSERT(meta);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
const std::size_t count = operation.GetOperandsCount();
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const bool has_array = meta->sampler.is_array;
const bool has_shadow = meta->sampler.is_shadow;
shader_ir: Clean texture management code Previous code relied on GLSL parameter order (something that's always ill-formed on an IR design). This approach passes spatial coordiantes through operation nodes and array and depth compare values in the the texture metadata. It still contains an "extra" vector containing generic nodes for bias and component index (for example) which is still a bit ill-formed but it should be better than the previous approach.
2019-01-29 08:31:40 +01:00
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
std::string expr = "texture" + function_suffix;
if (!meta->aoffi.empty()) {
expr += "Offset";
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
} else if (!meta->ptp.empty()) {
expr += "Offsets";
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
}
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (!meta->sampler.is_indexed) {
GL Backend: Introduce indexed samplers into the GL backend
2020-01-06 16:43:13 +01:00
expr += '(' + GetSampler(meta->sampler) + ", ";
} else {
Shader_IR: Propagate bindless index into the GL compiler.
2020-01-07 22:45:12 +01:00
expr += '(' + GetSampler(meta->sampler) + '[' + Visit(meta->index).AsUint() + "], ";
GL Backend: Introduce indexed samplers into the GL backend
2020-01-06 16:43:13 +01:00
}
Shader_IR: Correct TLD4S Depth Compare.
2019-12-12 00:43:43 +01:00
expr += coord_constructors.at(count + (has_array ? 1 : 0) +
gl_shader_decompiler: Rename "sepparate" to "separate"
2019-12-16 06:12:51 +01:00
(has_shadow && !separate_dc ? 1 : 0) - 1);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
expr += '(';
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
for (std::size_t i = 0; i < count; ++i) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
expr += Visit(operation[i]).AsFloat();
gl_shader_decompiler: Inline textureGather component
2019-01-08 00:31:47 +01:00
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
const std::size_t next = i + 1;
shader/decode: Remove extras from MetaTexture
2019-02-22 07:30:12 +01:00
if (next < count)
shader_ir: Clean texture management code Previous code relied on GLSL parameter order (something that's always ill-formed on an IR design). This approach passes spatial coordiantes through operation nodes and array and depth compare values in the the texture metadata. It still contains an "extra" vector containing generic nodes for bias and component index (for example) which is still a bit ill-formed but it should be better than the previous approach.
2019-01-29 08:31:40 +01:00
expr += ", ";
}
if (has_array) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
expr += ", float(" + Visit(meta->array).AsInt() + ')';
shader_ir: Clean texture management code Previous code relied on GLSL parameter order (something that's always ill-formed on an IR design). This approach passes spatial coordiantes through operation nodes and array and depth compare values in the the texture metadata. It still contains an "extra" vector containing generic nodes for bias and component index (for example) which is still a bit ill-formed but it should be better than the previous approach.
2019-01-29 08:31:40 +01:00
}
if (has_shadow) {
gl_shader_decompiler: Rename "sepparate" to "separate"
2019-12-16 06:12:51 +01:00
if (separate_dc) {
Gl_Shader_compiler: Correct Depth Compare for Texture Gather operations.
2019-12-11 21:10:12 +01:00
expr += "), " + Visit(meta->depth_compare).AsFloat();
} else {
expr += ", " + Visit(meta->depth_compare).AsFloat() + ')';
}
} else {
expr += ')';
shader_ir: Clean texture management code Previous code relied on GLSL parameter order (something that's always ill-formed on an IR design). This approach passes spatial coordiantes through operation nodes and array and depth compare values in the the texture metadata. It still contains an "extra" vector containing generic nodes for bias and component index (for example) which is still a bit ill-formed but it should be better than the previous approach.
2019-01-29 08:31:40 +01:00
}
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
for (const auto& variant : extras) {
if (const auto argument = std::get_if<TextureArgument>(&variant)) {
expr += GenerateTextureArgument(*argument);
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
} else if (std::holds_alternative<TextureOffset>(variant)) {
if (!meta->aoffi.empty()) {
expr += GenerateTextureAoffi(meta->aoffi);
} else if (!meta->ptp.empty()) {
expr += GenerateTexturePtp(meta->ptp);
}
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
} else if (std::holds_alternative<TextureDerivates>(variant)) {
expr += GenerateTextureDerivates(meta->derivates);
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
} else {
UNREACHABLE();
shader/decode: Remove extras from MetaTexture
2019-02-22 07:30:12 +01:00
}
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
}
shader/decode: Remove extras from MetaTexture
2019-02-22 07:30:12 +01:00
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
return expr + ')';
}
gl_shader_decompiler: Pass by reference to GenerateTextureArgument() Avoids an unnecessary atomic reference count increment and decrement.
2019-10-16 00:29:35 +02:00
std::string GenerateTextureArgument(const TextureArgument& argument) {
const auto& [type, operand] = argument;
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
if (operand == nullptr) {
return {};
}
std::string expr = ", ";
switch (type) {
case Type::Int:
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto immediate = std::get_if<ImmediateNode>(&*operand)) {
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
// Inline the string as an immediate integer in GLSL (some extra arguments are
// required to be constant)
expr += std::to_string(static_cast<s32>(immediate->GetValue()));
} else {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
expr += Visit(operand).AsInt();
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
}
break;
case Type::Float:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
expr += Visit(operand).AsFloat();
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
break;
default: {
const auto type_int = static_cast<u32>(type);
UNIMPLEMENTED_MSG("Unimplemented extra type={}", type_int);
expr += '0';
break;
}
}
return expr;
}
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
std::string ReadTextureOffset(const Node& value) {
if (const auto immediate = std::get_if<ImmediateNode>(&*value)) {
// Inline the string as an immediate integer in GLSL (AOFFI arguments are required
// to be constant by the standard).
return std::to_string(static_cast<s32>(immediate->GetValue()));
} else if (device.HasVariableAoffi()) {
// Avoid using variable AOFFI on unsupported devices.
return Visit(value).AsInt();
} else {
// Insert 0 on devices not supporting variable AOFFI.
return "0";
}
}
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
std::string GenerateTextureAoffi(const std::vector<Node>& aoffi) {
if (aoffi.empty()) {
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
constexpr std::array coord_constructors = {"int", "ivec2", "ivec3"};
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
std::string expr = ", ";
expr += coord_constructors.at(aoffi.size() - 1);
expr += '(';
for (std::size_t index = 0; index < aoffi.size(); ++index) {
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
expr += ReadTextureOffset(aoffi.at(index));
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
if (index + 1 < aoffi.size()) {
expr += ", ";
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
}
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
expr += ')';
shader_ir: Clean texture management code Previous code relied on GLSL parameter order (something that's always ill-formed on an IR design). This approach passes spatial coordiantes through operation nodes and array and depth compare values in the the texture metadata. It still contains an "extra" vector containing generic nodes for bias and component index (for example) which is still a bit ill-formed but it should be better than the previous approach.
2019-01-29 08:31:40 +01:00
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
return expr;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
std::string GenerateTexturePtp(const std::vector<Node>& ptp) {
static constexpr std::size_t num_vectors = 4;
ASSERT(ptp.size() == num_vectors * 2);
std::string expr = ", ivec2[](";
for (std::size_t vector = 0; vector < num_vectors; ++vector) {
const bool has_next = vector + 1 < num_vectors;
expr += fmt::format("ivec2({}, {}){}", ReadTextureOffset(ptp.at(vector * 2)),
ReadTextureOffset(ptp.at(vector * 2 + 1)), has_next ? ", " : "");
}
expr += ')';
return expr;
}
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
std::string GenerateTextureDerivates(const std::vector<Node>& derivates) {
if (derivates.empty()) {
return {};
}
constexpr std::array coord_constructors = {"float", "vec2", "vec3"};
std::string expr = ", ";
const std::size_t components = derivates.size() / 2;
std::string dx = coord_constructors.at(components - 1);
std::string dy = coord_constructors.at(components - 1);
dx += '(';
dy += '(';
for (std::size_t index = 0; index < components; ++index) {
gl_shader_decompiler: Avoid copies where applicable Avoids unnecessary reference count increments where applicable and also avoids reallocating a vector. Unlikely to make a huge difference, but given how trivial of an amendment it is, why not?
2020-04-18 02:47:00 +02:00
const auto& operand_x{derivates.at(index * 2)};
const auto& operand_y{derivates.at(index * 2 + 1)};
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
dx += Visit(operand_x).AsFloat();
dy += Visit(operand_y).AsFloat();
if (index + 1 < components) {
dx += ", ";
dy += ", ";
}
}
dx += ')';
dy += ')';
expr += dx + ", " + dy;
return expr;
}
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
std::string BuildIntegerCoordinates(Operation operation) {
constexpr std::array constructors{"int(", "ivec2(", "ivec3(", "ivec4("};
const std::size_t coords_count{operation.GetOperandsCount()};
std::string expr = constructors.at(coords_count - 1);
for (std::size_t i = 0; i < coords_count; ++i) {
expr += VisitOperand(operation, i).AsInt();
if (i + 1 < coords_count) {
expr += ", ";
}
}
expr += ')';
return expr;
}
std::string BuildImageValues(Operation operation) {
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
constexpr std::array constructors{"uint", "uvec2", "uvec3", "uvec4"};
gl_shader_decompiler: Avoid unnecessary copies of MetaImage MetaImage contains a std::vector, so copying here could result in unnecessary reallocations. Given the operation lives throughout the entire scope, this is safe to do.
2019-10-16 00:14:52 +02:00
const auto& meta{std::get<MetaImage>(operation.GetMeta())};
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
const std::size_t values_count{meta.values.size()};
std::string expr = fmt::format("{}(", constructors.at(values_count - 1));
for (std::size_t i = 0; i < values_count; ++i) {
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
expr += Visit(meta.values.at(i)).AsUint();
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
if (i + 1 < values_count) {
expr += ", ";
}
}
expr += ')';
return expr;
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Assign(Operation operation) {
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
const Node& dest = operation[0];
const Node& src = operation[1];
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression target;
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto gpr = std::get_if<GprNode>(&*dest)) {
shader_ir: Remove RZ and use Register::ZeroIndex instead
2018-12-26 05:49:32 +01:00
if (gpr->GetIndex() == Register::ZeroIndex) {
// Writing to Register::ZeroIndex is a no op
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
target = {GetRegister(gpr->GetIndex()), Type::Float};
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
} else if (const auto abuf = std::get_if<AbufNode>(&*dest)) {
shader: Add physical attributes commentaries
2019-05-01 00:46:49 +02:00
UNIMPLEMENTED_IF(abuf->IsPhysicalBuffer());
gl_shader_decompiler: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
auto output = GetOutputAttribute(abuf);
if (!output) {
return {};
}
target = std::move(*output);
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
} else if (const auto lmem = std::get_if<LmemNode>(&*dest)) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
target = {
fmt::format("{}[{} >> 2]", GetLocalMemory(), Visit(lmem->GetAddress()).AsUint()),
Type::Uint};
gl_shader_decompiler: Implement shared memory
2019-08-29 22:18:04 +02:00
} else if (const auto smem = std::get_if<SmemNode>(&*dest)) {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
ASSERT(stage == ShaderType::Compute);
gl_shader_cache: Specialize shared memory size Shared memory was being declared with an undefined size. Specialize from guest GPU parameters the compute shader's shared memory size.
2019-11-13 03:39:45 +01:00
target = {fmt::format("smem[{} >> 2]", Visit(smem->GetAddress()).AsUint()), Type::Uint};
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
} else if (const auto gmem = std::get_if<GmemNode>(&*dest)) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
const std::string real = Visit(gmem->GetRealAddress()).AsUint();
const std::string base = Visit(gmem->GetBaseAddress()).AsUint();
const std::string final_offset = fmt::format("({} - {}) >> 2", real, base);
target = {fmt::format("{}[{}]", GetGlobalMemory(gmem->GetDescriptor()), final_offset),
Type::Uint};
Shader_IR: Correct Custom Variable assignment.
2020-01-07 23:56:03 +01:00
} else if (const auto cv = std::get_if<CustomVarNode>(&*dest)) {
target = {GetCustomVariable(cv->GetIndex()), Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
} else {
UNREACHABLE_MSG("Assign called without a proper target");
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("{} = {};", target.GetCode(), Visit(src).As(target.GetType()));
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return {};
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Add(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "+", type, type, type);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Mul(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "*", type, type, type);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Div(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "/", type, type, type);
}
shader_decode: Implement HFMA2
2018-12-23 06:26:35 +01:00
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Fma(Operation operation) {
shader_decode: Implement HFMA2
2018-12-23 06:26:35 +01:00
return GenerateTernary(operation, "fma", type, type, type, type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Negate(Operation operation) {
return GenerateUnary(operation, "-", type, type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Absolute(Operation operation) {
return GenerateUnary(operation, "abs", type, type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FClamp(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateTernary(operation, "clamp", Type::Float, Type::Float, Type::Float,
Type::Float);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FCastHalf0(Operation operation) {
return {fmt::format("({})[0]", VisitOperand(operation, 0).AsHalfFloat()), Type::Float};
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 23:38:25 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FCastHalf1(Operation operation) {
return {fmt::format("({})[1]", VisitOperand(operation, 0).AsHalfFloat()), Type::Float};
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 23:38:25 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Min(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryCall(operation, "min", type, type, type);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Max(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryCall(operation, "max", type, type, type);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Select(Operation operation) {
const std::string condition = Visit(operation[0]).AsBool();
const std::string true_case = Visit(operation[1]).AsUint();
const std::string false_case = Visit(operation[2]).AsUint();
std::string op_str = fmt::format("({} ? {} : {})", condition, true_case, false_case);
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return ApplyPrecise(operation, std::move(op_str), Type::Uint);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FCos(Operation operation) {
return GenerateUnary(operation, "cos", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FSin(Operation operation) {
return GenerateUnary(operation, "sin", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FExp2(Operation operation) {
return GenerateUnary(operation, "exp2", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FLog2(Operation operation) {
return GenerateUnary(operation, "log2", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FInverseSqrt(Operation operation) {
return GenerateUnary(operation, "inversesqrt", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FSqrt(Operation operation) {
return GenerateUnary(operation, "sqrt", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FRoundEven(Operation operation) {
return GenerateUnary(operation, "roundEven", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FFloor(Operation operation) {
return GenerateUnary(operation, "floor", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FCeil(Operation operation) {
return GenerateUnary(operation, "ceil", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FTrunc(Operation operation) {
return GenerateUnary(operation, "trunc", Type::Float, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression FCastInteger(Operation operation) {
return GenerateUnary(operation, "float", Type::Float, type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
Expression FSwizzleAdd(Operation operation) {
const std::string op_a = VisitOperand(operation, 0).AsFloat();
const std::string op_b = VisitOperand(operation, 1).AsFloat();
gl_shader_decompiler: Add safe fallbacks when ARB_shader_ballot is not available
2019-11-08 00:03:50 +01:00
if (!device.HasShaderBallot()) {
LOG_ERROR(Render_OpenGL, "Shader ballot is unavailable but required by the shader");
return {fmt::format("{} + {}", op_a, op_b), Type::Float};
}
const std::string instr_mask = VisitOperand(operation, 2).AsUint();
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
const std::string mask = code.GenerateTemporary();
gl_shader_decompiler: Add safe fallbacks when ARB_shader_ballot is not available
2019-11-08 00:03:50 +01:00
code.AddLine("uint {} = ({} >> ((gl_SubGroupInvocationARB & 3) << 1)) & 3;", mask,
instr_mask);
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
gl_shader_decompiler: Add safe fallbacks when ARB_shader_ballot is not available
2019-11-08 00:03:50 +01:00
const std::string modifier_a = fmt::format("fswzadd_modifiers_a[{}]", mask);
const std::string modifier_b = fmt::format("fswzadd_modifiers_b[{}]", mask);
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
return {fmt::format("(({} * {}) + ({} * {}))", op_a, modifier_a, op_b, modifier_b),
Type::Float};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression ICastFloat(Operation operation) {
return GenerateUnary(operation, "int", Type::Int, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression ICastUnsigned(Operation operation) {
return GenerateUnary(operation, "int", Type::Int, Type::Uint);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalShiftLeft(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "<<", type, type, Type::Uint);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression ILogicalShiftRight(Operation operation) {
const std::string op_a = VisitOperand(operation, 0).AsUint();
const std::string op_b = VisitOperand(operation, 1).AsUint();
std::string op_str = fmt::format("int({} >> {})", op_a, op_b);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return ApplyPrecise(operation, std::move(op_str), Type::Int);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression IArithmeticShiftRight(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, ">>", Type::Int, Type::Int, Type::Uint);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BitwiseAnd(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "&", type, type, type);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BitwiseOr(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "|", type, type, type);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BitwiseXor(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "^", type, type, type);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BitwiseNot(Operation operation) {
return GenerateUnary(operation, "~", type, type);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression UCastFloat(Operation operation) {
return GenerateUnary(operation, "uint", Type::Uint, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression UCastSigned(Operation operation) {
return GenerateUnary(operation, "uint", Type::Uint, Type::Int);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression UShiftRight(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, ">>", Type::Uint, Type::Uint, Type::Uint);
}
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BitfieldInsert(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateQuaternary(operation, "bitfieldInsert", type, type, type, Type::Int,
Type::Int);
}
shader_decode: Use BitfieldExtract instead of shift + and
2018-12-26 06:58:47 +01:00
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BitfieldExtract(Operation operation) {
shader_decode: Use BitfieldExtract instead of shift + and
2018-12-26 06:58:47 +01:00
return GenerateTernary(operation, "bitfieldExtract", type, type, Type::Int, Type::Int);
}
shader_decode: Implement POPC
2018-12-23 05:33:47 +01:00
template <Type type>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BitCount(Operation operation) {
return GenerateUnary(operation, "bitCount", type, type);
shader_decode: Implement POPC
2018-12-23 05:33:47 +01:00
}
Shader_IR: Implement FLO instruction.
2019-11-12 15:07:22 +01:00
template <Type type>
Expression BitMSB(Operation operation) {
return GenerateUnary(operation, "findMSB", type, type);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression HNegate(Operation operation) {
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
const auto GetNegate = [&](std::size_t index) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return VisitOperand(operation, index).AsBool() + " ? -1 : 1";
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
};
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("({} * vec2({}, {}))", VisitOperand(operation, 0).AsHalfFloat(),
GetNegate(1), GetNegate(2)),
Type::HalfFloat};
}
Expression HClamp(Operation operation) {
const std::string value = VisitOperand(operation, 0).AsHalfFloat();
const std::string min = VisitOperand(operation, 1).AsFloat();
const std::string max = VisitOperand(operation, 2).AsFloat();
std::string clamped = fmt::format("clamp({}, vec2({}), vec2({}))", value, min, max);
return ApplyPrecise(operation, std::move(clamped), Type::HalfFloat);
}
Expression HCastFloat(Operation operation) {
gl_shader_decompiler: Fix casts from fp32 to f16 Casts from f32 to f16 zeroes the higher half of the target register.
2019-11-26 02:00:42 +01:00
return {fmt::format("vec2({}, 0.0f)", VisitOperand(operation, 0).AsFloat()),
Type::HalfFloat};
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
}
Expression HUnpack(Operation operation) {
Expression operand = VisitOperand(operation, 0);
switch (std::get<Tegra::Shader::HalfType>(operation.GetMeta())) {
case Tegra::Shader::HalfType::H0_H1:
return operand;
case Tegra::Shader::HalfType::F32:
return {fmt::format("vec2({})", operand.AsFloat()), Type::HalfFloat};
case Tegra::Shader::HalfType::H0_H0:
return {fmt::format("vec2({}[0])", operand.AsHalfFloat()), Type::HalfFloat};
case Tegra::Shader::HalfType::H1_H1:
return {fmt::format("vec2({}[1])", operand.AsHalfFloat()), Type::HalfFloat};
}
gl_shader_decompiler: Add tailing return for HUnpack2
2019-09-24 06:03:59 +02:00
UNREACHABLE();
return {"0", Type::Int};
shader_ir/decode: Fix half float pre-operations and remove MetaHalfArithmetic Operations done before the main half float operation (like HAdd) were managing a packed value instead of the unpacked one. Adding an unpacked operation allows us to drop the per-operand MetaHalfArithmetic entry, simplifying the code overall.
2019-04-16 00:48:11 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression HMergeF32(Operation operation) {
return {fmt::format("float({}[0])", VisitOperand(operation, 0).AsHalfFloat()), Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression HMergeH0(Operation operation) {
gl_shader_decompiler: Improve generated code in HMergeH* Avoiding bitwise expressions, this fixes Turing issues in shaders using half float merges that affected several games.
2020-04-12 10:06:55 +02:00
const std::string dest = VisitOperand(operation, 0).AsUint();
const std::string src = VisitOperand(operation, 1).AsUint();
Revert "gl_shader_decompiler: Implement merges with bitfieldInsert" This reverts commit 05cf27083608bebd3ee4c38f2f948c8f2030f881. Apparently the first approach using floats instead of bitfieldInert worked better for Fire Emblem: Three Houses. Reverting to get that behavior back.
2020-04-15 02:24:33 +02:00
return {fmt::format("vec2(unpackHalf2x16({}).x, unpackHalf2x16({}).y)", src, dest),
Type::HalfFloat};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression HMergeH1(Operation operation) {
gl_shader_decompiler: Improve generated code in HMergeH* Avoiding bitwise expressions, this fixes Turing issues in shaders using half float merges that affected several games.
2020-04-12 10:06:55 +02:00
const std::string dest = VisitOperand(operation, 0).AsUint();
const std::string src = VisitOperand(operation, 1).AsUint();
Revert "gl_shader_decompiler: Implement merges with bitfieldInsert" This reverts commit 05cf27083608bebd3ee4c38f2f948c8f2030f881. Apparently the first approach using floats instead of bitfieldInert worked better for Fire Emblem: Three Houses. Reverting to get that behavior back.
2020-04-15 02:24:33 +02:00
return {fmt::format("vec2(unpackHalf2x16({}).x, unpackHalf2x16({}).y)", dest, src),
Type::HalfFloat};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression HPack2(Operation operation) {
return {fmt::format("vec2({}, {})", VisitOperand(operation, 0).AsFloat(),
VisitOperand(operation, 1).AsFloat()),
Type::HalfFloat};
shader_ir: Remove composite primitives and use temporals instead
2018-12-27 05:50:22 +01:00
}
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
template <const std::string_view& op, Type type, bool unordered = false>
Expression Comparison(Operation operation) {
static_assert(!unordered || type == Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
const Expression expr = GenerateBinaryInfix(operation, op, Type::Bool, type, type);
gl_shader_decompiler: Properly emulate NaN behaviour on NE "Not equal" operators on GLSL seem to behave as unordered when we expect an ordered comparison. Manually emulate this checking for LGE values (numbers, not-NaNs).
2020-05-09 09:56:50 +02:00
if constexpr (op.compare("!=") == 0 && type == Type::Float && !unordered) {
// GLSL's operator!=(float, float) doesn't seem be ordered. This happens on both AMD's
// and Nvidia's proprietary stacks. Manually force an ordered comparison.
return {fmt::format("({} && !isnan({}) && !isnan({}))", expr.AsBool(),
VisitOperand(operation, 0).AsFloat(),
VisitOperand(operation, 1).AsFloat()),
Type::Bool};
}
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
if constexpr (!unordered) {
return expr;
}
// Unordered comparisons are always true for NaN operands.
return {fmt::format("({} || isnan({}) || isnan({}))", expr.AsBool(),
VisitOperand(operation, 0).AsFloat(),
VisitOperand(operation, 1).AsFloat()),
Type::Bool};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
Expression FOrdered(Operation operation) {
return {fmt::format("(!isnan({}) && !isnan({}))", VisitOperand(operation, 0).AsFloat(),
VisitOperand(operation, 1).AsFloat()),
Type::Bool};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
Expression FUnordered(Operation operation) {
return {fmt::format("(isnan({}) || isnan({}))", VisitOperand(operation, 0).AsFloat(),
VisitOperand(operation, 1).AsFloat()),
Type::Bool};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader/arithmetic_integer: Implement CC for IADD
2020-04-26 02:56:11 +02:00
Expression LogicalAddCarry(Operation operation) {
const std::string carry = code.GenerateTemporary();
code.AddLine("uint {};", carry);
code.AddLine("uaddCarry({}, {}, {});", VisitOperand(operation, 0).AsUint(),
VisitOperand(operation, 1).AsUint(), carry);
return {fmt::format("({} != 0)", carry), Type::Bool};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalFIsNan(Operation operation) {
return GenerateUnary(operation, "isnan", Type::Bool, Type::Float);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalAssign(Operation operation) {
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
const Node& dest = operation[0];
const Node& src = operation[1];
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
std::string target;
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto pred = std::get_if<PredicateNode>(&*dest)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
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);
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
} else if (const auto flag = std::get_if<InternalFlagNode>(&*dest)) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
target = GetInternalFlag(flag->GetFlag());
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("{} = {};", target, Visit(src).AsBool());
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalAnd(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "&&", Type::Bool, Type::Bool, Type::Bool);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalOr(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "||", Type::Bool, Type::Bool, Type::Bool);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalXor(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "^^", Type::Bool, Type::Bool, Type::Bool);
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalNegate(Operation operation) {
return GenerateUnary(operation, "!", Type::Bool, Type::Bool);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalPick2(Operation operation) {
return {fmt::format("{}[{}]", VisitOperand(operation, 0).AsBool2(),
VisitOperand(operation, 1).AsUint()),
Type::Bool};
shader_decode: Implement HSET2
2018-12-24 04:51:52 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LogicalAnd2(Operation operation) {
shader_decode: Rework HSETP2
2018-12-24 00:59:49 +01:00
return GenerateUnary(operation, "all", Type::Bool, Type::Bool2);
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
template <bool with_nan>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression GenerateHalfComparison(Operation operation, std::string_view compare_op) {
Expression comparison = GenerateBinaryCall(operation, compare_op, Type::Bool2,
Type::HalfFloat, Type::HalfFloat);
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
if constexpr (!with_nan) {
return comparison;
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("HalfFloatNanComparison({}, {}, {})", comparison.AsBool2(),
VisitOperand(operation, 0).AsHalfFloat(),
VisitOperand(operation, 1).AsHalfFloat()),
Type::Bool2};
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
}
template <bool with_nan>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Logical2HLessThan(Operation operation) {
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
return GenerateHalfComparison<with_nan>(operation, "lessThan");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
template <bool with_nan>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Logical2HEqual(Operation operation) {
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
return GenerateHalfComparison<with_nan>(operation, "equal");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
template <bool with_nan>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Logical2HLessEqual(Operation operation) {
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
return GenerateHalfComparison<with_nan>(operation, "lessThanEqual");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
template <bool with_nan>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Logical2HGreaterThan(Operation operation) {
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
return GenerateHalfComparison<with_nan>(operation, "greaterThan");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
template <bool with_nan>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Logical2HNotEqual(Operation operation) {
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
return GenerateHalfComparison<with_nan>(operation, "notEqual");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
template <bool with_nan>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Logical2HGreaterEqual(Operation operation) {
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
return GenerateHalfComparison<with_nan>(operation, "greaterThanEqual");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Texture(Operation operation) {
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
ASSERT(meta);
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
std::string expr = GenerateTexture(
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
operation, "", {TextureOffset{}, TextureArgument{Type::Float, meta->bias}});
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta->sampler.is_shadow) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
expr = "vec4(" + expr + ')';
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {expr + GetSwizzle(meta->element), Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression TextureLod(Operation operation) {
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
ASSERT(meta);
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
std::string expr = GenerateTexture(
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
operation, "Lod", {TextureArgument{Type::Float, meta->lod}, TextureOffset{}});
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta->sampler.is_shadow) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
expr = "vec4(" + expr + ')';
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {expr + GetSwizzle(meta->element), Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression TextureGather(Operation operation) {
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const auto type = meta.sampler.is_shadow ? Type::Float : Type::Int;
const bool separate_dc = meta.sampler.is_shadow;
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
std::vector<TextureIR> ir;
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta.sampler.is_shadow) {
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
ir = {TextureOffset{}};
Gl_Shader_compiler: Correct Depth Compare for Texture Gather operations.
2019-12-11 21:10:12 +01:00
} else {
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
ir = {TextureOffset{}, TextureArgument{type, meta.component}};
Gl_Shader_compiler: Correct Depth Compare for Texture Gather operations.
2019-12-11 21:10:12 +01:00
}
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
return {GenerateTexture(operation, "Gather", ir, separate_dc) + GetSwizzle(meta.element),
Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression TextureQueryDimensions(Operation operation) {
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
ASSERT(meta);
const std::string sampler = GetSampler(meta->sampler);
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
const std::string lod = VisitOperand(operation, 0).AsInt();
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
switch (meta->element) {
shader_ir: Remove composite primitives and use temporals instead
2018-12-27 05:50:22 +01:00
case 0:
case 1:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("textureSize({}, {}){}", sampler, lod, GetSwizzle(meta->element)),
Type::Int};
shader_ir: Remove composite primitives and use temporals instead
2018-12-27 05:50:22 +01:00
case 3:
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("textureQueryLevels({})", sampler), Type::Int};
shader_ir: Remove composite primitives and use temporals instead
2018-12-27 05:50:22 +01:00
}
UNREACHABLE();
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0", Type::Int};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression TextureQueryLod(Operation operation) {
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
ASSERT(meta);
if (meta->element < 2) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("int(({} * vec2(256)){})",
GenerateTexture(operation, "QueryLod", {}),
GetSwizzle(meta->element)),
Type::Int};
shader_ir: Remove composite primitives and use temporals instead
2018-12-27 05:50:22 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0", Type::Int};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression TexelFetch(Operation operation) {
constexpr std::array constructors = {"int", "ivec2", "ivec3", "ivec4"};
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
ASSERT(meta);
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
UNIMPLEMENTED_IF(meta->sampler.is_array);
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
const std::size_t count = operation.GetOperandsCount();
shader_decode: Implement TLDS (untested)
2018-12-23 05:18:33 +01:00
std::string expr = "texelFetch(";
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
expr += GetSampler(meta->sampler);
shader_decode: Implement TLDS (untested)
2018-12-23 05:18:33 +01:00
expr += ", ";
gl_shader_decompiler: Add layer component to texelFetch TexelFetch was not emitting the array component generating invalid GLSL.
2020-03-12 21:43:03 +01:00
expr += constructors.at(operation.GetOperandsCount() + (meta->array ? 1 : 0) - 1);
shader_decode: Implement TLDS (untested)
2018-12-23 05:18:33 +01:00
expr += '(';
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
for (std::size_t i = 0; i < count; ++i) {
gl_shader_decompiler: Add layer component to texelFetch TexelFetch was not emitting the array component generating invalid GLSL.
2020-03-12 21:43:03 +01:00
if (i > 0) {
shader_decode: Implement TLDS (untested)
2018-12-23 05:18:33 +01:00
expr += ", ";
gl_shader_decompiler: Add layer component to texelFetch TexelFetch was not emitting the array component generating invalid GLSL.
2020-03-12 21:43:03 +01:00
}
expr += VisitOperand(operation, i).AsInt();
shader_decode: Implement TLDS (untested)
2018-12-23 05:18:33 +01:00
}
gl_shader_decompiler: Add layer component to texelFetch TexelFetch was not emitting the array component generating invalid GLSL.
2020-03-12 21:43:03 +01:00
if (meta->array) {
expr += ", ";
expr += Visit(meta->array).AsInt();
}
expr += ')';
gl_shader_decompiler: Allow 1D textures to be texture buffers
2019-04-28 02:45:59 +02:00
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta->lod && !meta->sampler.is_buffer) {
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
expr += ", ";
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
expr += Visit(meta->lod).AsInt();
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
}
shader_decode: Implement TLDS (untested)
2018-12-23 05:18:33 +01:00
expr += ')';
gl_shader_decompiler: Allow 1D textures to be texture buffers
2019-04-28 02:45:59 +02:00
expr += GetSwizzle(meta->element);
shader_ir: Clean texture management code Previous code relied on GLSL parameter order (something that's always ill-formed on an IR design). This approach passes spatial coordiantes through operation nodes and array and depth compare values in the the texture metadata. It still contains an "extra" vector containing generic nodes for bias and component index (for example) which is still a bit ill-formed but it should be better than the previous approach.
2019-01-29 08:31:40 +01:00
shader/texture: Deduce texture buffers from locker Instead of specializing shaders to separate texture buffers from 1D textures, use the locker to deduce them while they are being decoded.
2019-11-06 08:32:43 +01:00
return {std::move(expr), Type::Float};
shader_decode: Implement TLDS (untested)
2018-12-23 05:18:33 +01:00
}
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
Expression TextureGradient(Operation operation) {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
shader/texture: Implement TLD4.PTP
2019-12-16 08:09:24 +01:00
std::string expr =
GenerateTexture(operation, "Grad", {TextureDerivates{}, TextureOffset{}});
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
return {std::move(expr) + GetSwizzle(meta.element), Type::Float};
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
}
shader/image: Implement SULD and remove irrelevant code * Implement SULD as float. * Remove conditional declaration of GL_ARB_shader_viewport_layer_array.
2019-09-18 06:07:01 +02:00
Expression ImageLoad(Operation operation) {
if (!device.HasImageLoadFormatted()) {
LOG_ERROR(Render_OpenGL,
"Device lacks GL_EXT_shader_image_load_formatted, stubbing image load");
return {"0", Type::Int};
}
gl_shader_decompiler: Avoid unnecessary copies of MetaImage MetaImage contains a std::vector, so copying here could result in unnecessary reallocations. Given the operation lives throughout the entire scope, this is safe to do.
2019-10-16 00:14:52 +02:00
const auto& meta{std::get<MetaImage>(operation.GetMeta())};
shader/image: Implement SULD and remove irrelevant code * Implement SULD as float. * Remove conditional declaration of GL_ARB_shader_viewport_layer_array.
2019-09-18 06:07:01 +02:00
return {fmt::format("imageLoad({}, {}){}", GetImage(meta.image),
BuildIntegerCoordinates(operation), GetSwizzle(meta.element)),
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
Type::Uint};
shader/image: Implement SULD and remove irrelevant code * Implement SULD as float. * Remove conditional declaration of GL_ARB_shader_viewport_layer_array.
2019-09-18 06:07:01 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression ImageStore(Operation operation) {
gl_shader_decompiler: Avoid unnecessary copies of MetaImage MetaImage contains a std::vector, so copying here could result in unnecessary reallocations. Given the operation lives throughout the entire scope, this is safe to do.
2019-10-16 00:14:52 +02:00
const auto& meta{std::get<MetaImage>(operation.GetMeta())};
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
code.AddLine("imageStore({}, {}, {});", GetImage(meta.image),
BuildIntegerCoordinates(operation), BuildImageValues(operation));
return {};
}
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
template <const std::string_view& opname>
Expression AtomicImage(Operation operation) {
gl_shader_decompiler: Avoid unnecessary copies of MetaImage MetaImage contains a std::vector, so copying here could result in unnecessary reallocations. Given the operation lives throughout the entire scope, this is safe to do.
2019-10-16 00:14:52 +02:00
const auto& meta{std::get<MetaImage>(operation.GetMeta())};
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
ASSERT(meta.values.size() == 1);
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
return {fmt::format("imageAtomic{}({}, {}, {})", opname, GetImage(meta.image),
BuildIntegerCoordinates(operation), Visit(meta.values[0]).AsUint()),
Type::Uint};
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
}
shader/memory: Implement ATOMS.ADD.U32
2020-01-16 08:00:52 +01:00
template <const std::string_view& opname, Type type>
Expression Atomic(Operation operation) {
gl_decompiler: min/max op not implement yet
2020-03-30 13:48:22 +02:00
if ((opname == Func::Min || opname == Func::Max) && type == Type::Int) {
UNIMPLEMENTED_MSG("Unimplemented Min & Max for atomic operations");
return {};
}
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
return {fmt::format("atomic{}({}, {})", opname, Visit(operation[0]).GetCode(),
shader/memory: Implement RED.E.ADD Implements a reduction operation. It's an atomic operation that doesn't return a value. This commit introduces another primitive because some shading languages might have a primitive for reduction operations.
2020-04-06 07:24:47 +02:00
Visit(operation[1]).AsUint()),
Type::Uint};
}
template <const std::string_view& opname, Type type>
Expression Reduce(Operation operation) {
code.AddLine("{};", Atomic<opname, type>(operation).GetCode());
return {};
shader/memory: Implement ATOMS.ADD.U32
2020-01-16 08:00:52 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Branch(Operation operation) {
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
const auto target = std::get_if<ImmediateNode>(&*operation[0]);
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
UNIMPLEMENTED_IF(!target);
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("jmp_to = 0x{:X}U;", target->GetValue());
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddLine("break;");
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BranchIndirect(Operation operation) {
const std::string op_a = VisitOperand(operation, 0).AsUint();
shader_ir: Implement BRX & BRA.CC
2019-06-25 03:25:38 +02:00
code.AddLine("jmp_to = {};", op_a);
code.AddLine("break;");
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression PushFlowStack(Operation operation) {
shader: Split SSY and PBK stack Hardware testing revealed that SSY and PBK push to a different stack, allowing code like this: SSY label1; PBK label2; SYNC; label1: PBK; label2: EXIT;
2019-06-02 23:52:07 +02:00
const auto stack = std::get<MetaStackClass>(operation.GetMeta());
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
const auto target = std::get_if<ImmediateNode>(&*operation[0]);
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
UNIMPLEMENTED_IF(!target);
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("{}[{}++] = 0x{:X}U;", FlowStackName(stack), FlowStackTopName(stack),
shader: Split SSY and PBK stack Hardware testing revealed that SSY and PBK push to a different stack, allowing code like this: SSY label1; PBK label2; SYNC; label1: PBK; label2: EXIT;
2019-06-02 23:52:07 +02:00
target->GetValue());
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression PopFlowStack(Operation operation) {
shader: Split SSY and PBK stack Hardware testing revealed that SSY and PBK push to a different stack, allowing code like this: SSY label1; PBK label2; SYNC; label1: PBK; label2: EXIT;
2019-06-02 23:52:07 +02:00
const auto stack = std::get<MetaStackClass>(operation.GetMeta());
code.AddLine("jmp_to = {}[--{}];", FlowStackName(stack), FlowStackTopName(stack));
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
code.AddLine("break;");
return {};
}
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
void PreExit() {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage != ShaderType::Fragment) {
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
return;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
const auto& used_registers = ir.GetRegisters();
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
const auto SafeGetRegister = [&](u32 reg) -> Expression {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// TODO(Rodrigo): Replace with contains once C++20 releases
if (used_registers.find(reg) != used_registers.end()) {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {GetRegister(reg), Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"0.0f", Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
};
UNIMPLEMENTED_IF_MSG(header.ps.omap.sample_mask != 0, "Sample mask write is unimplemented");
// Write the color outputs using the data in the shader registers, disabled
// rendertargets/components are skipped in the register assignment.
gl_rasterizer: Move alpha testing to the OpenGL pipeline Removes the alpha testing code from each fragment shader invocation.
2019-05-22 01:28:09 +02:00
u32 current_reg = 0;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
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)) {
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
code.AddLine("frag_color{}{} = {};", render_target, GetColorSwizzle(component),
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
SafeGetRegister(current_reg).AsFloat());
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
++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.
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
code.AddLine("gl_FragDepth = {};", SafeGetRegister(current_reg + 1).AsFloat());
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
}
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
Expression Exit(Operation operation) {
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
PreExit();
code.AddLine("return;");
return {};
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Discard(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// Enclose "discard" in a conditional, so that GLSL compilation does not complain
// about unexecuted instructions that may follow this.
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("if (true) {{");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
++code.scope;
code.AddLine("discard;");
--code.scope;
gl_shader_decompiler: Replace individual overloads with the fmt-based one Gets rid of the need to special-case brace handling depending on the overload used, and makes it consistent across the board with how fmt handles them. Strings with compile-time deducible strings are directly forwarded to std::string's constructor, so we don't need to worry about the performance difference here, as it'll be identical.
2019-05-14 23:59:25 +02:00
code.AddLine("}}");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression EmitVertex(Operation operation) {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
ASSERT_MSG(stage == ShaderType::Geometry,
video_core: Implement IR based geometry shaders
2018-12-24 06:24:38 +01:00
"EmitVertex is expected to be used in a geometry shader.");
code.AddLine("EmitVertex();");
return {};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression EndPrimitive(Operation operation) {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
ASSERT_MSG(stage == ShaderType::Geometry,
video_core: Implement IR based geometry shaders
2018-12-24 06:24:38 +01:00
"EndPrimitive is expected to be used in a geometry shader.");
code.AddLine("EndPrimitive();");
return {};
}
shader_ir/other: Implement S2R InvocationId
2019-10-30 22:17:27 +01:00
Expression InvocationId(Operation operation) {
return {"gl_InvocationID", Type::Int};
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression YNegate(Operation operation) {
gl_shader_decompiler: Fix typo "y_negate"->"y_direction"
2019-11-03 18:46:53 +01:00
return {"y_direction", Type::Float};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader: Implement S2R Tid{XYZ} and CtaId{XYZ}
2019-05-03 08:00:51 +02:00
template <u32 element>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression LocalInvocationId(Operation) {
return {"gl_LocalInvocationID"s + GetSwizzle(element), Type::Uint};
shader: Implement S2R Tid{XYZ} and CtaId{XYZ}
2019-05-03 08:00:51 +02:00
}
template <u32 element>
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression WorkGroupId(Operation) {
return {"gl_WorkGroupID"s + GetSwizzle(element), Type::Uint};
shader: Implement S2R Tid{XYZ} and CtaId{XYZ}
2019-05-03 08:00:51 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression BallotThread(Operation operation) {
const std::string value = VisitOperand(operation, 0).AsBool();
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
if (!device.HasWarpIntrinsics()) {
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
LOG_ERROR(Render_OpenGL, "Nvidia vote intrinsics are required by this shader");
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
// Stub on non-Nvidia devices by simulating all threads voting the same as the active
// one.
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("({} ? 0xFFFFFFFFU : 0U)", value), Type::Uint};
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("ballotThreadNV({})", value), Type::Uint};
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression Vote(Operation operation, const char* func) {
const std::string value = VisitOperand(operation, 0).AsBool();
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
if (!device.HasWarpIntrinsics()) {
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
LOG_ERROR(Render_OpenGL, "Nvidia vote intrinsics are required by this shader");
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
// Stub with a warp size of one.
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {value, Type::Bool};
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {fmt::format("{}({})", func, value), Type::Bool};
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression VoteAll(Operation operation) {
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
return Vote(operation, "allThreadsNV");
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression VoteAny(Operation operation) {
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
return Vote(operation, "anyThreadNV");
}
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
Expression VoteEqual(Operation operation) {
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
if (!device.HasWarpIntrinsics()) {
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
LOG_ERROR(Render_OpenGL, "Nvidia vote intrinsics are required by this shader");
// We must return true here since a stub for a theoretical warp size of 1.
// This will always return an equal result across all votes.
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
return {"true", Type::Bool};
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
}
return Vote(operation, "allThreadsEqualNV");
}
gl_shader_decompiler: Reimplement shuffles with platform agnostic intrinsics
2019-11-03 03:44:13 +01:00
Expression ThreadId(Operation operation) {
gl_shader_decompiler: Add safe fallbacks when ARB_shader_ballot is not available
2019-11-08 00:03:50 +01:00
if (!device.HasShaderBallot()) {
LOG_ERROR(Render_OpenGL, "Shader ballot is unavailable but required by the shader");
return {"0U", Type::Uint};
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
}
gl_shader_decompiler: Reimplement shuffles with platform agnostic intrinsics
2019-11-03 03:44:13 +01:00
return {"gl_SubGroupInvocationARB", Type::Uint};
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
}
gl_shader_decompiler: Reimplement shuffles with platform agnostic intrinsics
2019-11-03 03:44:13 +01:00
Expression ShuffleIndexed(Operation operation) {
gl_shader_decompiler: Add safe fallbacks when ARB_shader_ballot is not available
2019-11-08 00:03:50 +01:00
std::string value = VisitOperand(operation, 0).AsFloat();
if (!device.HasShaderBallot()) {
LOG_ERROR(Render_OpenGL, "Shader ballot is unavailable but required by the shader");
return {std::move(value), Type::Float};
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
}
gl_shader_decompiler: Reimplement shuffles with platform agnostic intrinsics
2019-11-03 03:44:13 +01:00
const std::string index = VisitOperand(operation, 1).AsUint();
return {fmt::format("readInvocationARB({}, {})", value, index), Type::Float};
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
}
shader: Implement MEMBAR.GL Implement using memoryBarrier in GLSL and OpMemoryBarrier on SPIR-V.
2019-12-10 01:46:12 +01:00
Expression MemoryBarrierGL(Operation) {
code.AddLine("memoryBarrier();");
return {};
}
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
struct Func final {
Func() = delete;
~Func() = delete;
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
static constexpr std::string_view LessThan = "<";
static constexpr std::string_view Equal = "==";
static constexpr std::string_view LessEqual = "<=";
static constexpr std::string_view GreaterThan = ">";
static constexpr std::string_view NotEqual = "!=";
static constexpr std::string_view GreaterEqual = ">=";
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
static constexpr std::string_view Add = "Add";
gl_decompiler: add atomic op
2020-03-13 17:07:05 +01:00
static constexpr std::string_view Min = "Min";
static constexpr std::string_view Max = "Max";
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
static constexpr std::string_view And = "And";
static constexpr std::string_view Or = "Or";
static constexpr std::string_view Xor = "Xor";
static constexpr std::string_view Exchange = "Exchange";
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
};
shader/half_set_predicate: Fix HSETP2 implementation
2019-07-20 03:20:34 +02:00
static constexpr std::array operation_decompilers = {
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::Assign,
&GLSLDecompiler::Select,
&GLSLDecompiler::Add<Type::Float>,
&GLSLDecompiler::Mul<Type::Float>,
&GLSLDecompiler::Div<Type::Float>,
&GLSLDecompiler::Fma<Type::Float>,
&GLSLDecompiler::Negate<Type::Float>,
&GLSLDecompiler::Absolute<Type::Float>,
&GLSLDecompiler::FClamp,
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 23:38:25 +02:00
&GLSLDecompiler::FCastHalf0,
&GLSLDecompiler::FCastHalf1,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::Min<Type::Float>,
&GLSLDecompiler::Max<Type::Float>,
&GLSLDecompiler::FCos,
&GLSLDecompiler::FSin,
&GLSLDecompiler::FExp2,
&GLSLDecompiler::FLog2,
&GLSLDecompiler::FInverseSqrt,
&GLSLDecompiler::FSqrt,
&GLSLDecompiler::FRoundEven,
&GLSLDecompiler::FFloor,
&GLSLDecompiler::FCeil,
&GLSLDecompiler::FTrunc,
&GLSLDecompiler::FCastInteger<Type::Int>,
&GLSLDecompiler::FCastInteger<Type::Uint>,
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
&GLSLDecompiler::FSwizzleAdd,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::Add<Type::Int>,
&GLSLDecompiler::Mul<Type::Int>,
&GLSLDecompiler::Div<Type::Int>,
&GLSLDecompiler::Negate<Type::Int>,
&GLSLDecompiler::Absolute<Type::Int>,
&GLSLDecompiler::Min<Type::Int>,
&GLSLDecompiler::Max<Type::Int>,
&GLSLDecompiler::ICastFloat,
&GLSLDecompiler::ICastUnsigned,
&GLSLDecompiler::LogicalShiftLeft<Type::Int>,
&GLSLDecompiler::ILogicalShiftRight,
&GLSLDecompiler::IArithmeticShiftRight,
&GLSLDecompiler::BitwiseAnd<Type::Int>,
&GLSLDecompiler::BitwiseOr<Type::Int>,
&GLSLDecompiler::BitwiseXor<Type::Int>,
&GLSLDecompiler::BitwiseNot<Type::Int>,
&GLSLDecompiler::BitfieldInsert<Type::Int>,
shader_decode: Use BitfieldExtract instead of shift + and
2018-12-26 06:58:47 +01:00
&GLSLDecompiler::BitfieldExtract<Type::Int>,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::BitCount<Type::Int>,
Shader_IR: Implement FLO instruction.
2019-11-12 15:07:22 +01:00
&GLSLDecompiler::BitMSB<Type::Int>,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::Add<Type::Uint>,
&GLSLDecompiler::Mul<Type::Uint>,
&GLSLDecompiler::Div<Type::Uint>,
&GLSLDecompiler::Min<Type::Uint>,
&GLSLDecompiler::Max<Type::Uint>,
&GLSLDecompiler::UCastFloat,
&GLSLDecompiler::UCastSigned,
&GLSLDecompiler::LogicalShiftLeft<Type::Uint>,
&GLSLDecompiler::UShiftRight,
&GLSLDecompiler::UShiftRight,
&GLSLDecompiler::BitwiseAnd<Type::Uint>,
&GLSLDecompiler::BitwiseOr<Type::Uint>,
&GLSLDecompiler::BitwiseXor<Type::Uint>,
&GLSLDecompiler::BitwiseNot<Type::Uint>,
&GLSLDecompiler::BitfieldInsert<Type::Uint>,
shader_decode: Use BitfieldExtract instead of shift + and
2018-12-26 06:58:47 +01:00
&GLSLDecompiler::BitfieldExtract<Type::Uint>,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::BitCount<Type::Uint>,
Shader_IR: Implement FLO instruction.
2019-11-12 15:07:22 +01:00
&GLSLDecompiler::BitMSB<Type::Uint>,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::Add<Type::HalfFloat>,
&GLSLDecompiler::Mul<Type::HalfFloat>,
&GLSLDecompiler::Fma<Type::HalfFloat>,
&GLSLDecompiler::Absolute<Type::HalfFloat>,
&GLSLDecompiler::HNegate,
shader_ir/decode: Implement half float saturation
2019-04-09 23:41:41 +02:00
&GLSLDecompiler::HClamp,
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 23:38:25 +02:00
&GLSLDecompiler::HCastFloat,
shader_ir/decode: Fix half float pre-operations and remove MetaHalfArithmetic Operations done before the main half float operation (like HAdd) were managing a packed value instead of the unpacked one. Adding an unpacked operation allows us to drop the per-operand MetaHalfArithmetic entry, simplifying the code overall.
2019-04-16 00:48:11 +02:00
&GLSLDecompiler::HUnpack,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::HMergeF32,
&GLSLDecompiler::HMergeH0,
&GLSLDecompiler::HMergeH1,
shader_ir: Remove composite primitives and use temporals instead
2018-12-27 05:50:22 +01:00
&GLSLDecompiler::HPack2,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::LogicalAssign,
&GLSLDecompiler::LogicalAnd,
&GLSLDecompiler::LogicalOr,
&GLSLDecompiler::LogicalXor,
&GLSLDecompiler::LogicalNegate,
&GLSLDecompiler::LogicalPick2,
shader/half_set_predicate: Fix HSETP2 implementation
2019-07-20 03:20:34 +02:00
&GLSLDecompiler::LogicalAnd2,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
&GLSLDecompiler::Comparison<Func::LessThan, Type::Float, false>,
&GLSLDecompiler::Comparison<Func::Equal, Type::Float, false>,
&GLSLDecompiler::Comparison<Func::LessEqual, Type::Float, false>,
&GLSLDecompiler::Comparison<Func::GreaterThan, Type::Float, false>,
&GLSLDecompiler::Comparison<Func::NotEqual, Type::Float, false>,
&GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Float, false>,
&GLSLDecompiler::FOrdered,
&GLSLDecompiler::FUnordered,
&GLSLDecompiler::Comparison<Func::LessThan, Type::Float, true>,
&GLSLDecompiler::Comparison<Func::Equal, Type::Float, true>,
&GLSLDecompiler::Comparison<Func::LessEqual, Type::Float, true>,
&GLSLDecompiler::Comparison<Func::GreaterThan, Type::Float, true>,
&GLSLDecompiler::Comparison<Func::NotEqual, Type::Float, true>,
&GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Float, true>,
&GLSLDecompiler::Comparison<Func::LessThan, Type::Int>,
&GLSLDecompiler::Comparison<Func::Equal, Type::Int>,
&GLSLDecompiler::Comparison<Func::LessEqual, Type::Int>,
&GLSLDecompiler::Comparison<Func::GreaterThan, Type::Int>,
&GLSLDecompiler::Comparison<Func::NotEqual, Type::Int>,
&GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Int>,
&GLSLDecompiler::Comparison<Func::LessThan, Type::Uint>,
&GLSLDecompiler::Comparison<Func::Equal, Type::Uint>,
&GLSLDecompiler::Comparison<Func::LessEqual, Type::Uint>,
&GLSLDecompiler::Comparison<Func::GreaterThan, Type::Uint>,
&GLSLDecompiler::Comparison<Func::NotEqual, Type::Uint>,
&GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Uint>,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
shader/arithmetic_integer: Implement CC for IADD
2020-04-26 02:56:11 +02:00
&GLSLDecompiler::LogicalAddCarry,
renderer_opengl: Implement half float NaN comparisons
2019-04-09 22:33:48 +02:00
&GLSLDecompiler::Logical2HLessThan<false>,
&GLSLDecompiler::Logical2HEqual<false>,
&GLSLDecompiler::Logical2HLessEqual<false>,
&GLSLDecompiler::Logical2HGreaterThan<false>,
&GLSLDecompiler::Logical2HNotEqual<false>,
&GLSLDecompiler::Logical2HGreaterEqual<false>,
&GLSLDecompiler::Logical2HLessThan<true>,
&GLSLDecompiler::Logical2HEqual<true>,
&GLSLDecompiler::Logical2HLessEqual<true>,
&GLSLDecompiler::Logical2HGreaterThan<true>,
&GLSLDecompiler::Logical2HNotEqual<true>,
&GLSLDecompiler::Logical2HGreaterEqual<true>,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
shader_ir: Remove F4 prefix to texture operations This was originally included because texture operations returned a vec4. These operations now return a single float and the F4 prefix doesn't mean anything.
2019-01-29 08:39:07 +01:00
&GLSLDecompiler::Texture,
&GLSLDecompiler::TextureLod,
&GLSLDecompiler::TextureGather,
&GLSLDecompiler::TextureQueryDimensions,
&GLSLDecompiler::TextureQueryLod,
&GLSLDecompiler::TexelFetch,
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
&GLSLDecompiler::TextureGradient,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
shader/image: Implement SULD and remove irrelevant code * Implement SULD as float. * Remove conditional declaration of GL_ARB_shader_viewport_layer_array.
2019-09-18 06:07:01 +02:00
&GLSLDecompiler::ImageLoad,
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
&GLSLDecompiler::ImageStore,
gl_shader_decompiler: Use uint for images and fix SUATOM In the process remove implementation of SUATOM.MIN and SUATOM.MAX as these require a distinction between U32 and S32. These have to be implemented with imageCompSwap loop.
2019-09-18 06:50:40 +02:00
&GLSLDecompiler::AtomicImage<Func::Add>,
&GLSLDecompiler::AtomicImage<Func::And>,
&GLSLDecompiler::AtomicImage<Func::Or>,
&GLSLDecompiler::AtomicImage<Func::Xor>,
&GLSLDecompiler::AtomicImage<Func::Exchange>,
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
gl_decompiler: add atomic op
2020-03-13 17:07:05 +01:00
&GLSLDecompiler::Atomic<Func::Exchange, Type::Uint>,
shader/memory: Implement ATOMS.ADD.U32
2020-01-16 08:00:52 +01:00
&GLSLDecompiler::Atomic<Func::Add, Type::Uint>,
gl_decompiler: add atomic op
2020-03-13 17:07:05 +01:00
&GLSLDecompiler::Atomic<Func::Min, Type::Uint>,
&GLSLDecompiler::Atomic<Func::Max, Type::Uint>,
&GLSLDecompiler::Atomic<Func::And, Type::Uint>,
&GLSLDecompiler::Atomic<Func::Or, Type::Uint>,
&GLSLDecompiler::Atomic<Func::Xor, Type::Uint>,
&GLSLDecompiler::Atomic<Func::Exchange, Type::Int>,
&GLSLDecompiler::Atomic<Func::Add, Type::Int>,
&GLSLDecompiler::Atomic<Func::Min, Type::Int>,
&GLSLDecompiler::Atomic<Func::Max, Type::Int>,
&GLSLDecompiler::Atomic<Func::And, Type::Int>,
&GLSLDecompiler::Atomic<Func::Or, Type::Int>,
&GLSLDecompiler::Atomic<Func::Xor, Type::Int>,
shader/memory: Implement ATOMS.ADD.U32
2020-01-16 08:00:52 +01:00
shader/memory: Implement RED.E.ADD Implements a reduction operation. It's an atomic operation that doesn't return a value. This commit introduces another primitive because some shading languages might have a primitive for reduction operations.
2020-04-06 07:24:47 +02:00
&GLSLDecompiler::Reduce<Func::Add, Type::Uint>,
&GLSLDecompiler::Reduce<Func::Min, Type::Uint>,
&GLSLDecompiler::Reduce<Func::Max, Type::Uint>,
&GLSLDecompiler::Reduce<Func::And, Type::Uint>,
&GLSLDecompiler::Reduce<Func::Or, Type::Uint>,
&GLSLDecompiler::Reduce<Func::Xor, Type::Uint>,
&GLSLDecompiler::Reduce<Func::Add, Type::Int>,
&GLSLDecompiler::Reduce<Func::Min, Type::Int>,
&GLSLDecompiler::Reduce<Func::Max, Type::Int>,
&GLSLDecompiler::Reduce<Func::And, Type::Int>,
&GLSLDecompiler::Reduce<Func::Or, Type::Int>,
&GLSLDecompiler::Reduce<Func::Xor, Type::Int>,
shader_decode: Use proper primitive names
2018-12-26 07:18:11 +01:00
&GLSLDecompiler::Branch,
shader_ir: Implement BRX & BRA.CC
2019-06-25 03:25:38 +02:00
&GLSLDecompiler::BranchIndirect,
shader_decode: Use proper primitive names
2018-12-26 07:18:11 +01:00
&GLSLDecompiler::PushFlowStack,
&GLSLDecompiler::PopFlowStack,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::Exit,
shader_decode: Use proper primitive names
2018-12-26 07:18:11 +01:00
&GLSLDecompiler::Discard,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::EmitVertex,
&GLSLDecompiler::EndPrimitive,
shader_ir/other: Implement S2R InvocationId
2019-10-30 22:17:27 +01:00
&GLSLDecompiler::InvocationId,
glsl_decompiler: Fixup permissive member function declarations
2018-12-24 07:10:13 +01:00
&GLSLDecompiler::YNegate,
shader: Implement S2R Tid{XYZ} and CtaId{XYZ}
2019-05-03 08:00:51 +02:00
&GLSLDecompiler::LocalInvocationId<0>,
&GLSLDecompiler::LocalInvocationId<1>,
&GLSLDecompiler::LocalInvocationId<2>,
&GLSLDecompiler::WorkGroupId<0>,
&GLSLDecompiler::WorkGroupId<1>,
&GLSLDecompiler::WorkGroupId<2>,
shader_ir: Implement VOTE Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
2019-08-10 04:50:21 +02:00
&GLSLDecompiler::BallotThread,
&GLSLDecompiler::VoteAll,
&GLSLDecompiler::VoteAny,
&GLSLDecompiler::VoteEqual,
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
gl_shader_decompiler: Reimplement shuffles with platform agnostic intrinsics
2019-11-03 03:44:13 +01:00
&GLSLDecompiler::ThreadId,
&GLSLDecompiler::ShuffleIndexed,
shader: Implement MEMBAR.GL Implement using memoryBarrier in GLSL and OpMemoryBarrier on SPIR-V.
2019-12-10 01:46:12 +01:00
&GLSLDecompiler::MemoryBarrierGL,
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
};
shader/half_set_predicate: Fix HSETP2 implementation
2019-07-20 03:20:34 +02:00
static_assert(operation_decompilers.size() == static_cast<std::size_t>(OperationCode::Amount));
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
std::string GetRegister(u32 index) const {
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
return AppendSuffix(index, "gpr");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
std::string GetCustomVariable(u32 index) const {
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
return AppendSuffix(index, "custom_var");
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
std::string GetPredicate(Tegra::Shader::Pred pred) const {
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
return AppendSuffix(static_cast<u32>(pred), "pred");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
std::string GetGenericInputAttribute(Attribute::Index attribute) const {
return AppendSuffix(GetGenericAttributeIndex(attribute), INPUT_ATTRIBUTE_NAME);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
std::unordered_map<u8, GenericVaryingDescription> varying_description;
std::string GetGenericOutputAttribute(Attribute::Index attribute, std::size_t element) const {
const u8 offset = static_cast<u8>(GetGenericAttributeIndex(attribute) * 4 + element);
const auto& description = varying_description.at(offset);
if (description.is_scalar) {
return description.name;
}
return fmt::format("{}[{}]", description.name, element - description.first_element);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetConstBuffer(u32 index) const {
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
return AppendSuffix(index, "cbuf");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader_decode: Implement LDG and basic cbuf tracking
2018-12-29 06:44:54 +01:00
std::string GetGlobalMemory(const GlobalMemoryBase& descriptor) const {
return fmt::format("gmem_{}_{}_{}", descriptor.cbuf_index, descriptor.cbuf_offset, suffix);
}
std::string GetGlobalMemoryBlock(const GlobalMemoryBase& descriptor) const {
return fmt::format("gmem_block_{}_{}_{}", descriptor.cbuf_index, descriptor.cbuf_offset,
suffix);
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
std::string GetConstBufferBlock(u32 index) const {
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
return AppendSuffix(index, "cbuf_block");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetLocalMemory() const {
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
if (suffix.empty()) {
return "lmem";
} else {
return "lmem_" + std::string{suffix};
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetInternalFlag(InternalFlag flag) const {
gl_shader_decompiler: Rework GLSL decompiler type system GLSL decompiler type system was broken. We converted all return values to float except for some cases where returning we couldn't and implicitly broke the rule of returning floats (e.g. for bools or bool pairs). Instead of doing this introduce class Expression that knows what type a return value has and when a consumer wants to use the string it asks for it with a required type, emitting a runtime error if types are incompatible. This has the disadvantage that there's more C++ code, but we can emit better GLSL code that's easier to read.
2019-08-24 22:29:19 +02:00
constexpr std::array InternalFlagNames = {"zero_flag", "sign_flag", "carry_flag",
"overflow_flag"};
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const auto index = static_cast<u32>(flag);
ASSERT(index < static_cast<u32>(InternalFlag::Amount));
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
if (suffix.empty()) {
return InternalFlagNames[index];
} else {
return fmt::format("{}_{}", InternalFlagNames[index], suffix);
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetSampler(const Sampler& sampler) const {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
return AppendSuffix(sampler.index, "sampler");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
std::string GetImage(const Image& image) const {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
return AppendSuffix(image.index, "image");
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
}
gl_shader_decompiler: Decorate output attributes with XFB layout We sometimes have to slice attributes in different parts. This is needed for example in instances where the game feedbacks 3 components but writes 4 from the shader (something that is possible with GL_NV_transform_feedback).
2020-03-02 22:55:39 +01:00
std::string AppendSuffix(u32 index, std::string_view name) const {
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
if (suffix.empty()) {
return fmt::format("{}{}", name, index);
} else {
return fmt::format("{}{}_{}", name, index, suffix);
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
u32 GetNumPhysicalInputAttributes() const {
gl_shader_decompiler: Remove deprecated function and its usages
2020-03-18 21:28:03 +01:00
return stage == ShaderType::Vertex ? GetNumPhysicalAttributes() : GetNumPhysicalVaryings();
gl_shader_decompiler: Implement GLSL physical attributes
2019-05-01 00:36:18 +02:00
}
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
u32 GetNumPhysicalAttributes() const {
return std::min<u32>(device.GetMaxVertexAttributes(), Maxwell::NumVertexAttributes);
}
u32 GetNumPhysicalVaryings() const {
gl_shader_decompiler: Remove guest "position" varying "position" was being written but not read anywhere besides geometry shaders, where it had the same value as gl_Position. This commit replaces "position" with gl_Position, reducing the complexity of our code and the emitted GLSL code.
2019-06-03 06:01:34 +02:00
return std::min<u32>(device.GetMaxVaryings(), Maxwell::NumVaryings);
gl_shader_decompiler: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
}
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
bool IsRenderTargetEnabled(u32 render_target) const {
for (u32 component = 0; component < 4; ++component) {
if (header.ps.IsColorComponentOutputEnabled(render_target, component)) {
return true;
}
}
return false;
}
gl_shader_decompiler: Use variable AOFFI on supported hardware
2019-04-10 23:03:52 +02:00
const Device& device;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const ShaderIR& ir;
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
const Registry& registry;
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
const ShaderType stage;
gl_shader_decompiler: Add identifier to decompiled code
2020-02-29 20:30:20 +01:00
const std::string_view identifier;
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
const std::string_view suffix;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const Header header;
vk/gl_shader_decompiler: Silence assertion on compute
2020-03-12 07:27:29 +01:00
std::unordered_map<u8, VaryingTFB> transform_feedback;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
ShaderWriter code;
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
std::optional<u32> max_input_vertices;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
};
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
std::string GetFlowVariable(u32 index) {
return fmt::format("flow_var{}", index);
Shader_ir: Address feedback
2019-10-04 23:23:16 +02:00
}
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
class ExprDecompiler {
public:
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
explicit ExprDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ExprAnd& expr) {
gl_shader_decompiler: Fix decompilation of condition codes Use Visit instead of reimplementing it. Fixes unimplemented negations for condition codes.
2020-01-17 23:06:27 +01:00
inner += '(';
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
std::visit(*this, *expr.operand1);
inner += " && ";
std::visit(*this, *expr.operand2);
inner += ')';
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ExprOr& expr) {
gl_shader_decompiler: Fix decompilation of condition codes Use Visit instead of reimplementing it. Fixes unimplemented negations for condition codes.
2020-01-17 23:06:27 +01:00
inner += '(';
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
std::visit(*this, *expr.operand1);
inner += " || ";
std::visit(*this, *expr.operand2);
inner += ')';
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ExprNot& expr) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
inner += '!';
std::visit(*this, *expr.operand1);
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ExprPredicate& expr) {
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
const auto pred = static_cast<Tegra::Shader::Pred>(expr.predicate);
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
inner += decomp.GetPredicate(pred);
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ExprCondCode& expr) {
gl_shader_decompiler: Fix decompilation of condition codes Use Visit instead of reimplementing it. Fixes unimplemented negations for condition codes.
2020-01-17 23:06:27 +01:00
inner += decomp.Visit(decomp.ir.GetConditionCode(expr.cc)).AsBool();
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ExprVar& expr) {
Shader_ir: Address feedback
2019-10-04 23:23:16 +02:00
inner += GetFlowVariable(expr.var_index);
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ExprBoolean& expr) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
inner += expr.value ? "true" : "false";
}
Shader_IR: Implement Fast BRX and allow multi-branches in the CFG.
2019-09-24 04:55:25 +02:00
void operator()(VideoCommon::Shader::ExprGprEqual& expr) {
gl_shader_decompiler: Fix decompilation of condition codes Use Visit instead of reimplementing it. Fixes unimplemented negations for condition codes.
2020-01-17 23:06:27 +01:00
inner += fmt::format("(ftou({}) == {})", decomp.GetRegister(expr.gpr), expr.value);
Shader_IR: Implement Fast BRX and allow multi-branches in the CFG.
2019-09-24 04:55:25 +02:00
}
gl_shader_decompiler: Make ExprDecompiler's GetResult() a const member function This is only ever used to read, but not write, the resulting string, so we can enforce this by making it a const member function.
2019-10-16 01:02:57 +02:00
const std::string& GetResult() const {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
return inner;
}
private:
GLSLDecompiler& decomp;
gl_shader_decompiler: Fix decompilation of condition codes Use Visit instead of reimplementing it. Fixes unimplemented negations for condition codes.
2020-01-17 23:06:27 +01:00
std::string inner;
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
};
class ASTDecompiler {
public:
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
explicit ASTDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTProgram& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
ASTNode current = ast.nodes.GetFirst();
while (current) {
Visit(current);
current = current->GetNext();
}
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTIfThen& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
ExprDecompiler expr_parser{decomp};
std::visit(expr_parser, *ast.condition);
decomp.code.AddLine("if ({}) {{", expr_parser.GetResult());
decomp.code.scope++;
ASTNode current = ast.nodes.GetFirst();
while (current) {
Visit(current);
current = current->GetNext();
}
decomp.code.scope--;
decomp.code.AddLine("}}");
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTIfElse& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
decomp.code.AddLine("else {{");
decomp.code.scope++;
ASTNode current = ast.nodes.GetFirst();
while (current) {
Visit(current);
current = current->GetNext();
}
decomp.code.scope--;
decomp.code.AddLine("}}");
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()([[maybe_unused]] const ASTBlockEncoded& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
UNREACHABLE();
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTBlockDecoded& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
decomp.VisitBlock(ast.nodes);
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTVarSet& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
ExprDecompiler expr_parser{decomp};
std::visit(expr_parser, *ast.condition);
Shader_ir: Address feedback
2019-10-04 23:23:16 +02:00
decomp.code.AddLine("{} = {};", GetFlowVariable(ast.index), expr_parser.GetResult());
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTLabel& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
decomp.code.AddLine("// Label_{}:", ast.index);
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()([[maybe_unused]] const ASTGoto& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
UNREACHABLE();
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTDoWhile& ast) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
ExprDecompiler expr_parser{decomp};
std::visit(expr_parser, *ast.condition);
decomp.code.AddLine("do {{");
decomp.code.scope++;
ASTNode current = ast.nodes.GetFirst();
while (current) {
Visit(current);
current = current->GetNext();
}
decomp.code.scope--;
decomp.code.AddLine("}} while({});", expr_parser.GetResult());
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTReturn& ast) {
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
const bool is_true = VideoCommon::Shader::ExprIsTrue(ast.condition);
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
if (!is_true) {
ExprDecompiler expr_parser{decomp};
std::visit(expr_parser, *ast.condition);
decomp.code.AddLine("if ({}) {{", expr_parser.GetResult());
decomp.code.scope++;
}
if (ast.kills) {
decomp.code.AddLine("discard;");
} else {
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
decomp.PreExit();
decomp.code.AddLine("return;");
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
if (!is_true) {
decomp.code.scope--;
decomp.code.AddLine("}}");
}
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void operator()(const ASTBreak& ast) {
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
const bool is_true = VideoCommon::Shader::ExprIsTrue(ast.condition);
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
if (!is_true) {
ExprDecompiler expr_parser{decomp};
std::visit(expr_parser, *ast.condition);
decomp.code.AddLine("if ({}) {{", expr_parser.GetResult());
decomp.code.scope++;
}
decomp.code.AddLine("break;");
if (!is_true) {
decomp.code.scope--;
decomp.code.AddLine("}}");
}
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
void Visit(const ASTNode& node) {
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
std::visit(*this, *node->GetInnerData());
}
private:
GLSLDecompiler& decomp;
};
void GLSLDecompiler::DecompileAST() {
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
const u32 num_flow_variables = ir.GetASTNumVariables();
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
for (u32 i = 0; i < num_flow_variables; i++) {
Shader_ir: Address feedback
2019-10-04 23:23:16 +02:00
code.AddLine("bool {} = false;", GetFlowVariable(i));
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
ASTDecompiler decompiler{*this};
gl_shader_decompiler: Mark ASTDecompiler/ExprDecompiler parameters as const references where applicable These member functions don't actually modify the input parameter, so we can make this explicit with the use of const.
2019-10-16 00:49:36 +02:00
decompiler.Visit(ir.GetASTProgram());
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
gl_shader_decompiler: Hide local definitions inside an anonymous namespace
2019-03-31 05:24:10 +02:00
} // Anonymous namespace
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
ShaderEntries MakeEntries(const VideoCommon::Shader::ShaderIR& ir) {
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
ShaderEntries entries;
for (const auto& cbuf : ir.GetConstantBuffers()) {
entries.const_buffers.emplace_back(cbuf.second.GetMaxOffset(), cbuf.second.IsIndirect(),
cbuf.first);
}
shader/node: Unpack bindless texture encoding Bindless textures were using u64 to pack the buffer and offset from where they come from. Drop this in favor of separated entries in the struct. Remove the usage of std::set in favor of std::list (it's not std::vector to avoid reference invalidations) for samplers and images.
2019-10-28 06:31:05 +01:00
for (const auto& [base, usage] : ir.GetGlobalMemory()) {
entries.global_memory_entries.emplace_back(base.cbuf_index, base.cbuf_offset, usage.is_read,
usage.is_written);
}
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
for (const auto& sampler : ir.GetSamplers()) {
entries.samplers.emplace_back(sampler);
}
shader/node: Unpack bindless texture encoding Bindless textures were using u64 to pack the buffer and offset from where they come from. Drop this in favor of separated entries in the struct. Remove the usage of std::set in favor of std::list (it's not std::vector to avoid reference invalidations) for samplers and images.
2019-10-28 06:31:05 +01:00
for (const auto& image : ir.GetImages()) {
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
entries.images.emplace_back(image);
}
gl_state_tracker: Implement dirty flags for clip distances and shaders
2019-12-29 06:03:05 +01:00
const auto clip_distances = ir.GetClipDistances();
for (std::size_t i = 0; i < std::size(clip_distances); ++i) {
entries.clip_distances = (clip_distances[i] ? 1U : 0U) << i;
}
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
entries.shader_length = ir.GetLength();
return entries;
}
shader/registry: Store graphics and compute metadata Store information GLSL forces us to provide but it's dynamic state in hardware (workgroup sizes, primitive topology, shared memory size).
2020-02-29 07:49:51 +01:00
std::string DecompileShader(const Device& device, const ShaderIR& ir, const Registry& registry,
gl_shader_decompiler: Add identifier to decompiled code
2020-02-29 20:30:20 +01:00
ShaderType stage, std::string_view identifier,
std::string_view suffix) {
GLSLDecompiler decompiler(device, ir, registry, stage, identifier, suffix);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
decompiler.Decompile();
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
return decompiler.GetResult();
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it.
2020-02-26 20:13:47 +01:00
} // namespace OpenGL
Copy permalink