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

2460 lines
86 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"
namespace OpenGL::GLShader {
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;
shader_decompiler: Improve Accuracy of Attribute Interpolation.
2019-02-13 02:14:39 +01:00
using Tegra::Shader::AttributeUse;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
using Tegra::Shader::Header;
using Tegra::Shader::IpaInterpMode;
using Tegra::Shader::IpaMode;
using Tegra::Shader::IpaSampleMode;
shader_ir: Remove RZ and use Register::ZeroIndex instead
2018-12-26 05:49:32 +01:00
using Tegra::Shader::Register;
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
struct TextureAoffi {};
using TextureArgument = std::pair<Type, Node>;
using TextureIR = std::variant<TextureAoffi, TextureArgument>;
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
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";
}
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
/// Generates code to use for a swizzle operation.
gl_shader_decompiler: Make GetSwizzle constexpr
2019-05-03 07:59:25 +02:00
constexpr const char* GetSwizzle(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
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
}
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: 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
}
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));
}
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
[[deprecated]] constexpr bool IsVertexShader(ShaderType stage) {
return stage == ShaderType::Vertex;
gl_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
class GLSLDecompiler final {
public:
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, ShaderType stage,
gl_shader_decompiler: Use variable AOFFI on supported hardware
2019-04-10 23:03:52 +02:00
std::string suffix)
: device{device}, ir{ir}, stage{stage}, suffix{suffix}, header{ir.GetHeader()} {}
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
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()) {
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();
void Decompile() {
DeclareVertex();
DeclareGeometry();
DeclareRegisters();
DeclarePredicates();
DeclareLocalMemory();
DeclareInternalFlags();
DeclareInputAttributes();
DeclareOutputAttributes();
DeclareConstantBuffers();
DeclareGlobalMemory();
DeclareSamplers();
DeclarePhysicalAttributeReader();
code.AddLine("void execute_{}() {{", suffix);
++code.scope;
if (ir.IsDecompiled()) {
DecompileAST();
} else {
DecompileBranchMode();
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("}}");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetResult() {
return code.GetResult();
}
private:
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
friend class ASTDecompiler;
friend class ExprDecompiler;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
void DeclareVertex() {
gl_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
if (!IsVertexShader(stage))
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return;
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
const auto topology = GetTopologyName(header.common3.output_topology);
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
const auto max_vertices = header.common4.max_output_vertices.Value();
code.AddLine("layout ({}, max_vertices = {}) out;", topology, max_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();
}
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;
code.AddLine("vec4 gl_Position;");
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_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
if (!IsVertexShader(stage) || 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_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
} else if ((ir.UsesLayer() || ir.UsesViewportIndex()) && IsVertexShader(stage) &&
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
}
VideoCore: Corrections to the MME Inliner and removal of hacky instance management.
2019-09-15 20:25:07 +02:00
if (ir.UsesInstanceId()) {
code.AddLine("int gl_InstanceID;");
}
if (ir.UsesVertexId()) {
code.AddLine("int gl_VertexID;");
}
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
}
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() {
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage == ShaderType::Compute) {
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
code.AddLine("#ifdef LOCAL_MEMORY_SIZE");
code.AddLine("uint {}[LOCAL_MEMORY_SIZE];", GetLocalMemory());
code.AddLine("#endif");
return;
}
const u64 local_memory_size = header.GetLocalMemorySize();
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
}
gl_shader_decompiler: Stub local memory size
2019-07-15 22:28:27 +02:00
const auto 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: Improve Accuracy of Attribute Interpolation.
2019-02-13 02:14:39 +01:00
std::string GetInputFlags(AttributeUse attribute) {
switch (attribute) {
case AttributeUse::Perspective:
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
// Default, Smooth
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
return {};
case AttributeUse::Constant:
return "flat ";
case AttributeUse::ScreenLinear:
return "noperspective ";
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
default:
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
case AttributeUse::Unused:
UNIMPLEMENTED_MSG("Unknown attribute usage index={}", static_cast<u32>(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
std::string name{GetInputAttribute(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) {
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 auto input_mode{header.ps.GetAttributeUse(location)};
gl_shader_decompiler: Skip physical unused attributes
2019-05-02 21:06:56 +02:00
if (skip_unused && input_mode == AttributeUse::Unused) {
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: Declare all possible varyings on physical attribute usage
2019-04-30 05:09:51 +02:00
void DeclareOutputAttribute(Attribute::Index index) {
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: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
code.AddLine("layout (location = {}) out vec4 {};", location, GetOutputAttribute(index));
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;
for (const auto& [index, cbuf] : ir.GetConstantBuffers()) {
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_shader_decompiler: Normalize image bindings
2019-11-22 08:34:14 +01:00
const std::string description = fmt::format("layout (binding = {}) uniform", binding++);
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/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
if (sampler.IsBuffer()) {
return "samplerBuffer";
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
switch (sampler.GetType()) {
case Tegra::Shader::TextureType::Texture1D:
return "sampler1D";
case Tegra::Shader::TextureType::Texture2D:
return "sampler2D";
case Tegra::Shader::TextureType::Texture3D:
return "sampler3D";
case Tegra::Shader::TextureType::TextureCube:
return "samplerCube";
default:
UNREACHABLE();
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
}
}();
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
if (sampler.IsArray()) {
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
}
if (sampler.IsShadow()) {
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/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
code.AddLine("{} {} {};", description, sampler_type, name);
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 ||
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
header.ps.GetAttributeUse(index) != AttributeUse::Unused;
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";
if (image.IsRead() && !image.IsWritten()) {
qualifier += " readonly";
} else if (image.IsWritten() && !image.IsRead()) {
qualifier += " writeonly";
}
gl_shader_decompiler: Fix clang build issues
2019-09-24 06:03:27 +02:00
const char* format = image.IsAtomic() ? "r32ui, " : "";
const char* type_declaration = GetImageTypeDeclaration(image.GetType());
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)) {
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: 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)) {
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.
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("gs_{}[{} % MAX_VERTEX_INPUT]", name, Visit(buffer).AsUint());
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:
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 {element == 3 ? "1.0f" : ("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();
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_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
ASSERT(IsVertexShader(stage));
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: 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 {GeometryPass(GetInputAttribute(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 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: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
return {{"gl_Position"s + GetSwizzle(abuf->GetElement()), 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:
switch (abuf->GetElement()) {
case 0:
UNIMPLEMENTED();
return {};
case 1:
gl_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
if (IsVertexShader(stage) && !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_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
if (IsVertexShader(stage) && !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:
UNIMPLEMENTED_MSG("Requires some state changes for gl_PointSize to work in shader");
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 {};
case Attribute::Index::ClipDistances0123:
gl_shader_decompiler: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
return {{fmt::format("gl_ClipDistance[{}]", abuf->GetElement()), 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: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
return {{fmt::format("gl_ClipDistance[{}]", abuf->GetElement() + 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: Avoid writing output attribute when unimplemented
2019-09-06 20:02:12 +02:00
return {
{GetOutputAttribute(attribute) + GetSwizzle(abuf->GetElement()), 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,
const std::vector<TextureIR>& extras) {
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: 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
const bool has_array = meta->sampler.IsArray();
const bool has_shadow = meta->sampler.IsShadow();
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";
}
expr += '(' + GetSampler(meta->sampler) + ", ";
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 += coord_constructors.at(count + (has_array ? 1 : 0) + (has_shadow ? 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: 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->depth_compare).AsFloat();
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 += ')';
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);
gl_shader_decompiler: Use std::holds_alternative within GenerateTexture() This only ever queries if the type exists within the variant, but doesn't actually do anything with the return value. We can just use std::holds_alternative for this use case.
2019-10-16 00:25:45 +02:00
} else if (std::holds_alternative<TextureAoffi>(variant)) {
gl_shader_decompiler: Add AOFFI backing implementation
2019-03-29 22:37:37 +01:00
expr += GenerateTextureAoffi(meta->aoffi);
} 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;
}
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) {
const auto operand{aoffi.at(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
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 (AOFFI arguments are required
// to be constant by the standard).
expr += std::to_string(static_cast<s32>(immediate->GetValue()));
gl_shader_decompiler: Use variable AOFFI on supported hardware
2019-04-10 23:03:52 +02:00
} else if (device.HasVariableAoffi()) {
// Avoid using variable AOFFI on unsupported devices.
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: Use variable AOFFI on supported hardware
2019-04-10 23:03:52 +02:00
} else {
// Insert 0 on devices not supporting variable AOFFI.
expr += '0';
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
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/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};
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
}
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) {
std::string dest = VisitOperand(operation, 0).AsUint();
std::string src = VisitOperand(operation, 1).AsUint();
return {fmt::format("(({} & 0x0000FFFFU) | ({} & 0xFFFF0000U))", src, dest), 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 HMergeH1(Operation operation) {
std::string dest = VisitOperand(operation, 0).AsUint();
std::string src = VisitOperand(operation, 1).AsUint();
return {fmt::format("(({} & 0x0000FFFFU) | ({} & 0xFFFF0000U))", dest, src), 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 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
}
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 LogicalLessThan(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "<", Type::Bool, 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 LogicalEqual(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "==", Type::Bool, 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 LogicalLessEqual(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "<=", Type::Bool, 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 LogicalGreaterThan(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, ">", Type::Bool, 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 LogicalNotEqual(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, "!=", Type::Bool, 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 LogicalGreaterEqual(Operation operation) {
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
return GenerateBinaryInfix(operation, ">=", Type::Bool, 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 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(
operation, "", {TextureAoffi{}, TextureArgument{Type::Float, meta->bias}});
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
if (meta->sampler.IsShadow()) {
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(
operation, "Lod", {TextureArgument{Type::Float, meta->lod}, TextureAoffi{}});
gl_shader_decompiler: replace std::get<> with std::get_if<> for macOS compatibility
2019-01-15 21:52:49 +01:00
if (meta->sampler.IsShadow()) {
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) {
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/decode: Remove extras from MetaTexture
2019-02-22 07:30:12 +01:00
const auto type = meta->sampler.IsShadow() ? Type::Float : 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
return {GenerateTexture(operation, "Gather",
GLSLDecompiler: Correct Texture Gather Offset. This commit corrects the argument ordering in textureGatherOffset.
2019-11-07 16:30:41 +01:00
{TextureAoffi{}, TextureArgument{type, meta->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
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: 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
UNIMPLEMENTED_IF(meta->sampler.IsArray());
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: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
expr += constructors.at(operation.GetOperandsCount() - 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: 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 += VisitOperand(operation, i).AsInt();
gl_shader_decompiler: Re-implement TLDS lod
2019-02-12 21:02:59 +01:00
const std::size_t next = i + 1;
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 (next == count)
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
else if (next < count)
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
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
if (meta->lod && !meta->sampler.IsBuffer()) {
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/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
}
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_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
code.AddLine("FragColor{}[{}] = {};", render_target, 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 {};
}
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
}
struct Func final {
Func() = delete;
~Func() = delete;
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";
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>,
&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>,
&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
&GLSLDecompiler::LogicalLessThan<Type::Float>,
&GLSLDecompiler::LogicalEqual<Type::Float>,
&GLSLDecompiler::LogicalLessEqual<Type::Float>,
&GLSLDecompiler::LogicalGreaterThan<Type::Float>,
&GLSLDecompiler::LogicalNotEqual<Type::Float>,
&GLSLDecompiler::LogicalGreaterEqual<Type::Float>,
&GLSLDecompiler::LogicalFIsNan,
&GLSLDecompiler::LogicalLessThan<Type::Int>,
&GLSLDecompiler::LogicalEqual<Type::Int>,
&GLSLDecompiler::LogicalLessEqual<Type::Int>,
&GLSLDecompiler::LogicalGreaterThan<Type::Int>,
&GLSLDecompiler::LogicalNotEqual<Type::Int>,
&GLSLDecompiler::LogicalGreaterEqual<Type::Int>,
&GLSLDecompiler::LogicalLessThan<Type::Uint>,
&GLSLDecompiler::LogicalEqual<Type::Uint>,
&GLSLDecompiler::LogicalLessEqual<Type::Uint>,
&GLSLDecompiler::LogicalGreaterThan<Type::Uint>,
&GLSLDecompiler::LogicalNotEqual<Type::Uint>,
&GLSLDecompiler::LogicalGreaterEqual<Type::Uint>,
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,
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
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,
&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,
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 {
return GetDeclarationWithSuffix(index, "gpr");
}
std::string GetPredicate(Tegra::Shader::Pred pred) const {
return GetDeclarationWithSuffix(static_cast<u32>(pred), "pred");
}
std::string GetInputAttribute(Attribute::Index attribute) const {
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
return GetDeclarationWithSuffix(GetGenericAttributeIndex(attribute), "input_attr");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetOutputAttribute(Attribute::Index attribute) const {
gl_shader_decompiler: Abstract generic attribute operations
2019-04-30 05:18:28 +02:00
return GetDeclarationWithSuffix(GetGenericAttributeIndex(attribute), "output_attr");
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetConstBuffer(u32 index) const {
return GetDeclarationWithSuffix(index, "cbuf");
}
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 {
return GetDeclarationWithSuffix(index, "cbuf_block");
}
std::string GetLocalMemory() const {
return "lmem_" + suffix;
}
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_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
return fmt::format("{}_{}", InternalFlagNames[index], suffix);
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
std::string GetSampler(const Sampler& sampler) const {
video_core: Address feedback
2018-12-21 07:39:46 +01:00
return GetDeclarationWithSuffix(static_cast<u32>(sampler.GetIndex()), "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 {
return GetDeclarationWithSuffix(static_cast<u32>(image.GetIndex()), "image");
}
gl_shader_decompiler: Use a std::string_view with GetDeclarationWithSuffix() This allows the function to be completely non-allocating for inputs of all sizes (i.e. there's no heap cost for an input to convert to a std::string_view).
2019-10-16 01:00:20 +02:00
std::string GetDeclarationWithSuffix(u32 index, std::string_view name) const {
gl_shader_decompiler: Utilize fmt overload of AddLine() where applicable
2019-05-14 18:18:07 +02:00
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_rasterizer: Implement compute shaders
2019-07-15 03:25:13 +02:00
return IsVertexShader(stage) ? 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_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;
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
const ShaderType stage;
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
const std::string suffix;
const Header header;
ShaderWriter code;
};
Shader_ir: Address feedback
2019-10-04 23:23:16 +02:00
std::string GetFlowVariable(u32 i) {
gl_shader_decompiler: Fold flow_var constant into GetFlowVariable() This is only ever used within this function, so we can narrow it's scope down.
2019-10-16 00:58:33 +02:00
return fmt::format("flow_var_{}", i);
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: Implement AST decompiling
2019-06-29 07:44:07 +02:00
inner += "( ";
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: Implement AST decompiling
2019-06-29 07:44:07 +02:00
inner += "( ";
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: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
const Node cc = decomp.ir.GetConditionCode(expr.cc);
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
std::string target;
if (const auto pred = std::get_if<PredicateNode>(&*cc)) {
const auto index = pred->GetIndex();
switch (index) {
case Tegra::Shader::Pred::NeverExecute:
target = "false";
gl_shader_decompiler: Resolve fallthrough within ExprDecompiler's ExprCondCode operator() This would previously result in NeverExecute and UnusedIndex being treated as regular predicates.
2019-10-16 01:38:47 +02:00
break;
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
case Tegra::Shader::Pred::UnusedIndex:
target = "true";
gl_shader_decompiler: Resolve fallthrough within ExprDecompiler's ExprCondCode operator() This would previously result in NeverExecute and UnusedIndex being treated as regular predicates.
2019-10-16 01:38:47 +02:00
break;
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
default:
target = decomp.GetPredicate(index);
gl_shader_decompiler: Resolve fallthrough within ExprDecompiler's ExprCondCode operator() This would previously result in NeverExecute and UnusedIndex being treated as regular predicates.
2019-10-16 01:38:47 +02:00
break;
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
} else if (const auto flag = std::get_if<InternalFlagNode>(&*cc)) {
target = decomp.GetInternalFlag(flag->GetFlag());
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
} else {
UNREACHABLE();
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
}
inner += target;
}
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) {
inner +=
"( ftou(" + decomp.GetRegister(expr.gpr) + ") == " + std::to_string(expr.value) + ')';
}
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:
gl_shader_decompiler: Refactor and address feedback.
2019-09-22 18:33:13 +02:00
std::string inner;
gl_shader_decompiler: Implement AST decompiling
2019-06-29 07:44:07 +02:00
GLSLDecompiler& decomp;
};
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_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
ShaderEntries GetEntries(const VideoCommon::Shader::ShaderIR& ir) {
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);
}
entries.clip_distances = ir.GetClipDistances();
entries.shader_length = ir.GetLength();
return entries;
}
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
std::string GetCommonDeclarations() {
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
return R"(#define ftoi floatBitsToInt
#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);
}
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
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 );
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
)";
glsl_decompiler: Implementation
2018-12-21 01:45:49 +01:00
}
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
std::string Decompile(const Device& device, const ShaderIR& ir, ShaderType stage,
gl_shader_decompiler: Move entries to a separate function
2019-09-25 04:34:18 +02:00
const std::string& suffix) {
gl_shader_decompiler: Use variable AOFFI on supported hardware
2019-04-10 23:03:52 +02:00
GLSLDecompiler decompiler(device, ir, stage, 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
}
shader_decompiler: Improve Accuracy of Attribute Interpolation.
2019-02-13 02:14:39 +01:00
} // namespace OpenGL::GLShader
Copy permalink