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

3094 lines
123 KiB
C++
Raw Normal View History

vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
// Copyright 2019 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
#include <functional>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
#include <limits>
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
#include <map>
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
#include <optional>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
#include <type_traits>
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
#include <unordered_map>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
#include <utility>
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
#include <fmt/format.h>
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
#include <sirit/sirit.h>
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
#include "common/alignment.h"
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
#include "common/assert.h"
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
#include "common/common_types.h"
#include "common/logging/log.h"
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
#include "video_core/engines/maxwell_3d.h"
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
#include "video_core/engines/shader_bytecode.h"
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
#include "video_core/engines/shader_header.h"
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
#include "video_core/engines/shader_type.h"
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
#include "video_core/renderer_vulkan/vk_device.h"
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
#include "video_core/renderer_vulkan/vk_shader_decompiler.h"
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
#include "video_core/shader/node.h"
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
#include "video_core/shader/shader_ir.h"
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
#include "video_core/shader/transform_feedback.h"
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
namespace Vulkan {
namespace {
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
using Sirit::Id;
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
using Tegra::Engines::ShaderType;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
using Tegra::Shader::Attribute;
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
using Tegra::Shader::PixelImap;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
using Tegra::Shader::Register;
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
using namespace VideoCommon::Shader;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
using Maxwell = Tegra::Engines::Maxwell3D::Regs;
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
using Operation = const OperationNode&;
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
class ASTDecompiler;
class ExprDecompiler;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
// TODO(Rodrigo): Use rasterizer's value
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
constexpr u32 MaxConstBufferFloats = 0x4000;
constexpr u32 MaxConstBufferElements = MaxConstBufferFloats / 4;
constexpr u32 NumInputPatches = 32; // This value seems to be the standard
enum class Type { Void, Bool, Bool2, Float, Int, Uint, HalfFloat };
class Expression final {
public:
Expression(Id id, Type type) : id{id}, type{type} {
ASSERT(type != Type::Void);
}
Expression() : type{Type::Void} {}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id id{};
Type type{};
};
static_assert(std::is_standard_layout_v<Expression>);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
struct TexelBuffer {
Id image_type{};
Id image{};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
struct SampledImage {
Id image_type{};
vk_shader_decompiler: Implement indexed textures Implement accessing textures through an index. It uses the same interface as OpenGL, the main difference is that Vulkan bindings are forced to be arrayed (the binding index doesn't change for stacked textures in SPIR-V).
2020-02-23 06:35:16 +01:00
Id sampler_type{};
Id sampler_pointer_type{};
Id variable{};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
};
struct StorageImage {
Id image_type{};
Id image{};
};
struct AttributeType {
Type type;
Id scalar;
Id vector;
};
struct VertexIndices {
std::optional<u32> position;
vk_shader_decompiler: Implement Layer output attribute SPIR-V's Layer is GLSL's gl_Layer. It lets the application choose from a shader stage (vertex, tessellation or geometry) which framebuffer layer write the output fragments to.
2020-02-16 06:40:17 +01:00
std::optional<u32> layer;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
std::optional<u32> viewport;
std::optional<u32> point_size;
std::optional<u32> clip_distances;
};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
struct GenericVaryingDescription {
Id id = nullptr;
u32 first_element = 0;
bool is_scalar = false;
};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
spv::Dim GetSamplerDim(const Sampler& sampler) {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
ASSERT(!sampler.is_buffer);
switch (sampler.type) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
case Tegra::Shader::TextureType::Texture1D:
return spv::Dim::Dim1D;
case Tegra::Shader::TextureType::Texture2D:
return spv::Dim::Dim2D;
case Tegra::Shader::TextureType::Texture3D:
return spv::Dim::Dim3D;
case Tegra::Shader::TextureType::TextureCube:
return spv::Dim::Cube;
default:
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
UNIMPLEMENTED_MSG("Unimplemented sampler type={}", static_cast<int>(sampler.type));
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
return spv::Dim::Dim2D;
}
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
std::pair<spv::Dim, bool> GetImageDim(const Image& image) {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
switch (image.type) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case Tegra::Shader::ImageType::Texture1D:
return {spv::Dim::Dim1D, false};
case Tegra::Shader::ImageType::TextureBuffer:
return {spv::Dim::Buffer, false};
case Tegra::Shader::ImageType::Texture1DArray:
return {spv::Dim::Dim1D, true};
case Tegra::Shader::ImageType::Texture2D:
return {spv::Dim::Dim2D, false};
case Tegra::Shader::ImageType::Texture2DArray:
return {spv::Dim::Dim2D, true};
case Tegra::Shader::ImageType::Texture3D:
return {spv::Dim::Dim3D, false};
default:
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
UNIMPLEMENTED_MSG("Unimplemented image type={}", static_cast<int>(image.type));
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {spv::Dim::Dim2D, false};
}
}
/// Returns the number of vertices present in a primitive topology.
u32 GetNumPrimitiveTopologyVertices(Maxwell::PrimitiveTopology primitive_topology) {
switch (primitive_topology) {
case Maxwell::PrimitiveTopology::Points:
return 1;
case Maxwell::PrimitiveTopology::Lines:
case Maxwell::PrimitiveTopology::LineLoop:
case Maxwell::PrimitiveTopology::LineStrip:
return 2;
case Maxwell::PrimitiveTopology::Triangles:
case Maxwell::PrimitiveTopology::TriangleStrip:
case Maxwell::PrimitiveTopology::TriangleFan:
return 3;
case Maxwell::PrimitiveTopology::LinesAdjacency:
case Maxwell::PrimitiveTopology::LineStripAdjacency:
return 4;
case Maxwell::PrimitiveTopology::TrianglesAdjacency:
case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
return 6;
case Maxwell::PrimitiveTopology::Quads:
UNIMPLEMENTED_MSG("Quads");
return 3;
case Maxwell::PrimitiveTopology::QuadStrip:
UNIMPLEMENTED_MSG("QuadStrip");
return 3;
case Maxwell::PrimitiveTopology::Polygon:
UNIMPLEMENTED_MSG("Polygon");
return 3;
case Maxwell::PrimitiveTopology::Patches:
UNIMPLEMENTED_MSG("Patches");
return 3;
default:
UNREACHABLE();
return 3;
}
}
spv::ExecutionMode GetExecutionMode(Maxwell::TessellationPrimitive primitive) {
switch (primitive) {
case Maxwell::TessellationPrimitive::Isolines:
return spv::ExecutionMode::Isolines;
case Maxwell::TessellationPrimitive::Triangles:
return spv::ExecutionMode::Triangles;
case Maxwell::TessellationPrimitive::Quads:
return spv::ExecutionMode::Quads;
}
UNREACHABLE();
return spv::ExecutionMode::Triangles;
}
spv::ExecutionMode GetExecutionMode(Maxwell::TessellationSpacing spacing) {
switch (spacing) {
case Maxwell::TessellationSpacing::Equal:
return spv::ExecutionMode::SpacingEqual;
case Maxwell::TessellationSpacing::FractionalOdd:
return spv::ExecutionMode::SpacingFractionalOdd;
case Maxwell::TessellationSpacing::FractionalEven:
return spv::ExecutionMode::SpacingFractionalEven;
}
UNREACHABLE();
return spv::ExecutionMode::SpacingEqual;
}
spv::ExecutionMode GetExecutionMode(Maxwell::PrimitiveTopology input_topology) {
switch (input_topology) {
case Maxwell::PrimitiveTopology::Points:
return spv::ExecutionMode::InputPoints;
case Maxwell::PrimitiveTopology::Lines:
case Maxwell::PrimitiveTopology::LineLoop:
case Maxwell::PrimitiveTopology::LineStrip:
return spv::ExecutionMode::InputLines;
case Maxwell::PrimitiveTopology::Triangles:
case Maxwell::PrimitiveTopology::TriangleStrip:
case Maxwell::PrimitiveTopology::TriangleFan:
return spv::ExecutionMode::Triangles;
case Maxwell::PrimitiveTopology::LinesAdjacency:
case Maxwell::PrimitiveTopology::LineStripAdjacency:
return spv::ExecutionMode::InputLinesAdjacency;
case Maxwell::PrimitiveTopology::TrianglesAdjacency:
case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
return spv::ExecutionMode::InputTrianglesAdjacency;
case Maxwell::PrimitiveTopology::Quads:
UNIMPLEMENTED_MSG("Quads");
return spv::ExecutionMode::Triangles;
case Maxwell::PrimitiveTopology::QuadStrip:
UNIMPLEMENTED_MSG("QuadStrip");
return spv::ExecutionMode::Triangles;
case Maxwell::PrimitiveTopology::Polygon:
UNIMPLEMENTED_MSG("Polygon");
return spv::ExecutionMode::Triangles;
case Maxwell::PrimitiveTopology::Patches:
UNIMPLEMENTED_MSG("Patches");
return spv::ExecutionMode::Triangles;
}
UNREACHABLE();
return spv::ExecutionMode::Triangles;
}
spv::ExecutionMode GetExecutionMode(Tegra::Shader::OutputTopology output_topology) {
switch (output_topology) {
case Tegra::Shader::OutputTopology::PointList:
return spv::ExecutionMode::OutputPoints;
case Tegra::Shader::OutputTopology::LineStrip:
return spv::ExecutionMode::OutputLineStrip;
case Tegra::Shader::OutputTopology::TriangleStrip:
return spv::ExecutionMode::OutputTriangleStrip;
default:
UNREACHABLE();
return spv::ExecutionMode::OutputPoints;
}
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
/// Returns true if an attribute index is one of the 32 generic attributes
constexpr bool IsGenericAttribute(Attribute::Index attribute) {
return attribute >= Attribute::Index::Attribute_0 &&
attribute <= Attribute::Index::Attribute_31;
}
/// Returns the location of a generic attribute
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
u32 GetGenericAttributeLocation(Attribute::Index attribute) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
ASSERT(IsGenericAttribute(attribute));
return static_cast<u32>(attribute) - static_cast<u32>(Attribute::Index::Attribute_0);
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
/// Returns true if an object has to be treated as precise
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()};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
if (std::holds_alternative<MetaArithmetic>(meta)) {
return std::get<MetaArithmetic>(meta).precise;
}
return false;
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
class SPIRVDecompiler final : public Sirit::Module {
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
public:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
explicit SPIRVDecompiler(const VKDevice& device, const ShaderIR& ir, ShaderType stage,
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
const Registry& registry, const Specialization& specialization)
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
: Module(0x00010300), device{device}, ir{ir}, stage{stage}, header{ir.GetHeader()},
vk/gl_shader_decompiler: Silence assertion on compute
2020-03-12 07:27:29 +01:00
registry{registry}, specialization{specialization} {
if (stage != ShaderType::Compute) {
transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
AddCapability(spv::Capability::Shader);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddCapability(spv::Capability::UniformAndStorageBuffer16BitAccess);
AddCapability(spv::Capability::ImageQuery);
AddCapability(spv::Capability::Image1D);
AddCapability(spv::Capability::ImageBuffer);
AddCapability(spv::Capability::ImageGatherExtended);
AddCapability(spv::Capability::SampledBuffer);
AddCapability(spv::Capability::StorageImageWriteWithoutFormat);
vk_shader_decompiler: Fix vertex id and instance id Vulkan's VertexIndex and InstanceIndex don't match with hardware. This is because Nvidia implements gl_VertexID and gl_InstanceID. The math that relates these is: gl_VertexIndex = gl_BaseVertex + gl_VertexID gl_InstanceIndex = gl_InstanceIndex + gl_InstanceID To emulate it using what Vulkan's SPIR-V offers (the *Index variants) this commit substracts gl_Base* from gl_*Index to obtain the OpenGL and hardware's equivalent.
2020-02-14 00:25:28 +01:00
AddCapability(spv::Capability::DrawParameters);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddCapability(spv::Capability::SubgroupBallotKHR);
AddCapability(spv::Capability::SubgroupVoteKHR);
AddExtension("SPV_KHR_shader_ballot");
AddExtension("SPV_KHR_subgroup_vote");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
AddExtension("SPV_KHR_storage_buffer_storage_class");
AddExtension("SPV_KHR_variable_pointers");
vk_shader_decompiler: Fix vertex id and instance id Vulkan's VertexIndex and InstanceIndex don't match with hardware. This is because Nvidia implements gl_VertexID and gl_InstanceID. The math that relates these is: gl_VertexIndex = gl_BaseVertex + gl_VertexID gl_InstanceIndex = gl_InstanceIndex + gl_InstanceID To emulate it using what Vulkan's SPIR-V offers (the *Index variants) this commit substracts gl_Base* from gl_*Index to obtain the OpenGL and hardware's equivalent.
2020-02-14 00:25:28 +01:00
AddExtension("SPV_KHR_shader_draw_parameters");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
if (!transform_feedback.empty()) {
if (device.IsExtTransformFeedbackSupported()) {
AddCapability(spv::Capability::TransformFeedback);
} else {
LOG_ERROR(Render_Vulkan, "Shader requires transform feedbacks but these are not "
"supported on this device");
}
}
vk_shader_decompiler: Implement Layer output attribute SPIR-V's Layer is GLSL's gl_Layer. It lets the application choose from a shader stage (vertex, tessellation or geometry) which framebuffer layer write the output fragments to.
2020-02-16 06:40:17 +01:00
if (ir.UsesLayer() || ir.UsesViewportIndex()) {
if (ir.UsesViewportIndex()) {
AddCapability(spv::Capability::MultiViewport);
}
if (stage != ShaderType::Geometry && device.IsExtShaderViewportIndexLayerSupported()) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddExtension("SPV_EXT_shader_viewport_index_layer");
AddCapability(spv::Capability::ShaderViewportIndexLayerEXT);
}
}
vk_device: Shrink formatless capability name size
2020-03-06 09:06:02 +01:00
if (device.IsFormatlessImageLoadSupported()) {
shader_decompiler: only add StorageImageReadWithoutFormat when available
2020-02-20 03:28:13 +01:00
AddCapability(spv::Capability::StorageImageReadWithoutFormat);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (device.IsFloat16Supported()) {
AddCapability(spv::Capability::Float16);
}
t_scalar_half = Name(TypeFloat(device.IsFloat16Supported() ? 16 : 32), "scalar_half");
t_half = Name(TypeVector(t_scalar_half, 2), "half");
const Id main = Decompile();
switch (stage) {
case ShaderType::Vertex:
AddEntryPoint(spv::ExecutionModel::Vertex, main, "main", interfaces);
break;
case ShaderType::TesselationControl:
AddCapability(spv::Capability::Tessellation);
AddEntryPoint(spv::ExecutionModel::TessellationControl, main, "main", interfaces);
AddExecutionMode(main, spv::ExecutionMode::OutputVertices,
header.common2.threads_per_input_primitive);
break;
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
case ShaderType::TesselationEval: {
const auto& info = registry.GetGraphicsInfo();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddCapability(spv::Capability::Tessellation);
AddEntryPoint(spv::ExecutionModel::TessellationEvaluation, main, "main", interfaces);
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
AddExecutionMode(main, GetExecutionMode(info.tessellation_primitive));
AddExecutionMode(main, GetExecutionMode(info.tessellation_spacing));
AddExecutionMode(main, info.tessellation_clockwise
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
? spv::ExecutionMode::VertexOrderCw
: spv::ExecutionMode::VertexOrderCcw);
break;
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
}
case ShaderType::Geometry: {
const auto& info = registry.GetGraphicsInfo();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddCapability(spv::Capability::Geometry);
AddEntryPoint(spv::ExecutionModel::Geometry, main, "main", interfaces);
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
AddExecutionMode(main, GetExecutionMode(info.primitive_topology));
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddExecutionMode(main, GetExecutionMode(header.common3.output_topology));
AddExecutionMode(main, spv::ExecutionMode::OutputVertices,
header.common4.max_output_vertices);
// TODO(Rodrigo): Where can we get this info from?
AddExecutionMode(main, spv::ExecutionMode::Invocations, 1U);
break;
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case ShaderType::Fragment:
AddEntryPoint(spv::ExecutionModel::Fragment, main, "main", interfaces);
AddExecutionMode(main, spv::ExecutionMode::OriginUpperLeft);
if (header.ps.omap.depth) {
AddExecutionMode(main, spv::ExecutionMode::DepthReplacing);
}
break;
case ShaderType::Compute:
const auto workgroup_size = specialization.workgroup_size;
AddExecutionMode(main, spv::ExecutionMode::LocalSize, workgroup_size[0],
workgroup_size[1], workgroup_size[2]);
AddEntryPoint(spv::ExecutionModel::GLCompute, main, "main", interfaces);
break;
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
private:
Id Decompile() {
DeclareCommon();
DeclareVertex();
DeclareTessControl();
DeclareTessEval();
DeclareGeometry();
DeclareFragment();
DeclareCompute();
DeclareRegisters();
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
DeclareCustomVariables();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
DeclarePredicates();
DeclareLocalMemory();
DeclareSharedMemory();
DeclareInternalFlags();
DeclareInputAttributes();
DeclareOutputAttributes();
u32 binding = specialization.base_binding;
binding = DeclareConstantBuffers(binding);
binding = DeclareGlobalBuffers(binding);
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
binding = DeclareUniformTexels(binding);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
binding = DeclareSamplers(binding);
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
binding = DeclareStorageTexels(binding);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
binding = DeclareImages(binding);
const Id main = OpFunction(t_void, {}, TypeFunction(t_void));
AddLabel();
if (ir.IsDecompiled()) {
DeclareFlowVariables();
DecompileAST();
} else {
AllocateLabels();
DecompileBranchMode();
}
OpReturn();
OpFunctionEnd();
return main;
}
void DefinePrologue() {
if (stage == ShaderType::Vertex) {
// Clear Position to avoid reading trash on the Z conversion.
const auto position_index = out_indices.position.value();
const Id position = AccessElement(t_out_float4, out_vertex, position_index);
vk_shader_decompiler: Fix default varying regression
2020-03-12 06:35:31 +01:00
OpStore(position, v_varying_default);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (specialization.point_size) {
const u32 point_size_index = out_indices.point_size.value();
const Id out_point_size = AccessElement(t_out_float, out_vertex, point_size_index);
OpStore(out_point_size, Constant(t_float, *specialization.point_size));
}
}
}
void DecompileAST();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
void DecompileBranchMode() {
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
const u32 first_address = ir.GetBasicBlocks().begin()->first;
const Id loop_label = OpLabel("loop");
const Id merge_label = OpLabel("merge");
const Id dummy_label = OpLabel();
const Id jump_label = OpLabel();
continue_label = OpLabel("continue");
std::vector<Sirit::Literal> literals;
std::vector<Id> branch_labels;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
for (const auto& [literal, label] : labels) {
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
literals.push_back(literal);
branch_labels.push_back(label);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
jmp_to = OpVariable(TypePointer(spv::StorageClass::Function, t_uint),
spv::StorageClass::Function, Constant(t_uint, first_address));
AddLocalVariable(jmp_to);
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
std::tie(ssy_flow_stack, ssy_flow_stack_top) = CreateFlowStack();
std::tie(pbk_flow_stack, pbk_flow_stack_top) = CreateFlowStack();
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
Name(jmp_to, "jmp_to");
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
Name(ssy_flow_stack, "ssy_flow_stack");
Name(ssy_flow_stack_top, "ssy_flow_stack_top");
Name(pbk_flow_stack, "pbk_flow_stack");
Name(pbk_flow_stack_top, "pbk_flow_stack_top");
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
DefinePrologue();
OpBranch(loop_label);
AddLabel(loop_label);
OpLoopMerge(merge_label, continue_label, spv::LoopControlMask::MaskNone);
OpBranch(dummy_label);
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddLabel(dummy_label);
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
const Id default_branch = OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id jmp_to_load = OpLoad(t_uint, jmp_to);
OpSelectionMerge(jump_label, spv::SelectionControlMask::MaskNone);
OpSwitch(jmp_to_load, default_branch, literals, branch_labels);
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddLabel(default_branch);
OpReturn();
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
for (const auto& [address, bb] : ir.GetBasicBlocks()) {
AddLabel(labels.at(address));
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
VisitBasicBlock(bb);
const auto next_it = labels.lower_bound(address + 1);
const Id next_label = next_it != labels.end() ? next_it->second : default_branch;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpBranch(next_label);
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
}
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddLabel(jump_label);
OpBranch(continue_label);
AddLabel(continue_label);
OpBranch(loop_label);
AddLabel(merge_label);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
private:
friend class ASTDecompiler;
friend class ExprDecompiler;
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
static constexpr auto INTERNAL_FLAGS_COUNT = static_cast<std::size_t>(InternalFlag::Amount);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
void AllocateLabels() {
for (const auto& pair : ir.GetBasicBlocks()) {
const u32 address = pair.first;
labels.emplace(address, OpLabel(fmt::format("label_0x{:x}", address)));
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
void DeclareCommon() {
thread_id =
DeclareInputBuiltIn(spv::BuiltIn::SubgroupLocalInvocationId, t_in_uint, "thread_id");
shader/other: Implement thread comparisons (NV_shader_thread_group) Hardware S2R special registers match gl_Thread*MaskNV. We can trivially implement these using Nvidia's extension on OpenGL or naively stubbing them with the ARB instructions to match. This might cause issues if the host device warp size doesn't match Nvidia's. That said, this is unlikely on proper shaders. Refer to the attached url for more documentation about these flags. https://www.khronos.org/registry/OpenGL/extensions/NV/NV_shader_thread_group.txt
2020-05-15 06:43:44 +02:00
thread_masks[0] =
DeclareInputBuiltIn(spv::BuiltIn::SubgroupEqMask, t_in_uint4, "thread_eq_mask");
thread_masks[1] =
DeclareInputBuiltIn(spv::BuiltIn::SubgroupGeMask, t_in_uint4, "thread_ge_mask");
thread_masks[2] =
DeclareInputBuiltIn(spv::BuiltIn::SubgroupGtMask, t_in_uint4, "thread_gt_mask");
thread_masks[3] =
DeclareInputBuiltIn(spv::BuiltIn::SubgroupLeMask, t_in_uint4, "thread_le_mask");
thread_masks[4] =
DeclareInputBuiltIn(spv::BuiltIn::SubgroupLtMask, t_in_uint4, "thread_lt_mask");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
void DeclareVertex() {
if (stage != ShaderType::Vertex) {
return;
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id out_vertex_struct;
std::tie(out_vertex_struct, out_indices) = DeclareVertexStruct();
const Id vertex_ptr = TypePointer(spv::StorageClass::Output, out_vertex_struct);
out_vertex = OpVariable(vertex_ptr, spv::StorageClass::Output);
interfaces.push_back(AddGlobalVariable(Name(out_vertex, "out_vertex")));
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
// Declare input attributes
vk_shader_decompiler: Fix vertex id and instance id Vulkan's VertexIndex and InstanceIndex don't match with hardware. This is because Nvidia implements gl_VertexID and gl_InstanceID. The math that relates these is: gl_VertexIndex = gl_BaseVertex + gl_VertexID gl_InstanceIndex = gl_InstanceIndex + gl_InstanceID To emulate it using what Vulkan's SPIR-V offers (the *Index variants) this commit substracts gl_Base* from gl_*Index to obtain the OpenGL and hardware's equivalent.
2020-02-14 00:25:28 +01:00
vertex_index = DeclareInputBuiltIn(spv::BuiltIn::VertexIndex, t_in_int, "vertex_index");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
instance_index =
vk_shader_decompiler: Fix vertex id and instance id Vulkan's VertexIndex and InstanceIndex don't match with hardware. This is because Nvidia implements gl_VertexID and gl_InstanceID. The math that relates these is: gl_VertexIndex = gl_BaseVertex + gl_VertexID gl_InstanceIndex = gl_InstanceIndex + gl_InstanceID To emulate it using what Vulkan's SPIR-V offers (the *Index variants) this commit substracts gl_Base* from gl_*Index to obtain the OpenGL and hardware's equivalent.
2020-02-14 00:25:28 +01:00
DeclareInputBuiltIn(spv::BuiltIn::InstanceIndex, t_in_int, "instance_index");
base_vertex = DeclareInputBuiltIn(spv::BuiltIn::BaseVertex, t_in_int, "base_vertex");
base_instance = DeclareInputBuiltIn(spv::BuiltIn::BaseInstance, t_in_int, "base_instance");
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
void DeclareTessControl() {
if (stage != ShaderType::TesselationControl) {
return;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
DeclareInputVertexArray(NumInputPatches);
DeclareOutputVertexArray(header.common2.threads_per_input_primitive);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
tess_level_outer = DeclareBuiltIn(
spv::BuiltIn::TessLevelOuter, spv::StorageClass::Output,
TypePointer(spv::StorageClass::Output, TypeArray(t_float, Constant(t_uint, 4U))),
"tess_level_outer");
Decorate(tess_level_outer, spv::Decoration::Patch);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
tess_level_inner = DeclareBuiltIn(
spv::BuiltIn::TessLevelInner, spv::StorageClass::Output,
TypePointer(spv::StorageClass::Output, TypeArray(t_float, Constant(t_uint, 2U))),
"tess_level_inner");
Decorate(tess_level_inner, spv::Decoration::Patch);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
invocation_id = DeclareInputBuiltIn(spv::BuiltIn::InvocationId, t_in_int, "invocation_id");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
void DeclareTessEval() {
if (stage != ShaderType::TesselationEval) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
return;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
DeclareInputVertexArray(NumInputPatches);
DeclareOutputVertex();
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
tess_coord = DeclareInputBuiltIn(spv::BuiltIn::TessCoord, t_in_float3, "tess_coord");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
void DeclareGeometry() {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (stage != ShaderType::Geometry) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
return;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
const auto& info = registry.GetGraphicsInfo();
const u32 num_input = GetNumPrimitiveTopologyVertices(info.primitive_topology);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
DeclareInputVertexArray(num_input);
DeclareOutputVertex();
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
void DeclareFragment() {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (stage != ShaderType::Fragment) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
return;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Disable default values on unwritten render targets Some games like The Legend of Zelda: Breath of the Wild assign render targets without writing them from the fragment shader. This generates Vulkan validation errors, so silence these I previously introduced a commit to set "vec4(0, 0, 0, 1)" for these attachments. The problem is that this is not what games expect. This commit reverts that change.
2020-01-24 05:15:50 +01:00
for (u32 rt = 0; rt < static_cast<u32>(std::size(frag_colors)); ++rt) {
if (!IsRenderTargetEnabled(rt)) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
continue;
}
const Id id = AddGlobalVariable(OpVariable(t_out_float4, spv::StorageClass::Output));
Name(id, fmt::format("frag_color{}", rt));
Decorate(id, spv::Decoration::Location, rt);
frag_colors[rt] = id;
interfaces.push_back(id);
}
if (header.ps.omap.depth) {
frag_depth = AddGlobalVariable(OpVariable(t_out_float, spv::StorageClass::Output));
Name(frag_depth, "frag_depth");
Decorate(frag_depth, spv::Decoration::BuiltIn,
static_cast<u32>(spv::BuiltIn::FragDepth));
interfaces.push_back(frag_depth);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
frag_coord = DeclareInputBuiltIn(spv::BuiltIn::FragCoord, t_in_float4, "frag_coord");
front_facing = DeclareInputBuiltIn(spv::BuiltIn::FrontFacing, t_in_bool, "front_facing");
point_coord = DeclareInputBuiltIn(spv::BuiltIn::PointCoord, t_in_float2, "point_coord");
}
void DeclareCompute() {
if (stage != ShaderType::Compute) {
return;
}
workgroup_id = DeclareInputBuiltIn(spv::BuiltIn::WorkgroupId, t_in_uint3, "workgroup_id");
local_invocation_id =
DeclareInputBuiltIn(spv::BuiltIn::LocalInvocationId, t_in_uint3, "local_invocation_id");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
void DeclareRegisters() {
for (const u32 gpr : ir.GetRegisters()) {
const Id id = OpVariable(t_prv_float, spv::StorageClass::Private, v_float_zero);
Name(id, fmt::format("gpr_{}", gpr));
registers.emplace(gpr, AddGlobalVariable(id));
}
}
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
void DeclareCustomVariables() {
Shader_IR: Address feedback.
2020-01-24 15:44:34 +01:00
const u32 num_custom_variables = ir.GetNumCustomVariables();
for (u32 i = 0; i < num_custom_variables; ++i) {
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
const Id id = OpVariable(t_prv_float, spv::StorageClass::Private, v_float_zero);
Name(id, fmt::format("custom_var_{}", i));
custom_variables.emplace(i, AddGlobalVariable(id));
}
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
void DeclarePredicates() {
for (const auto pred : ir.GetPredicates()) {
const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
Name(id, fmt::format("pred_{}", static_cast<u32>(pred)));
predicates.emplace(pred, AddGlobalVariable(id));
}
}
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
void DeclareFlowVariables() {
for (u32 i = 0; i < ir.GetASTNumVariables(); i++) {
const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
Name(id, fmt::format("flow_var_{}", static_cast<u32>(i)));
flow_variables.emplace(i, AddGlobalVariable(id));
}
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
void DeclareLocalMemory() {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
// TODO(Rodrigo): Unstub kernel local memory size and pass it from a register at
// specialization time.
const u64 lmem_size = stage == ShaderType::Compute ? 0x400 : header.GetLocalMemorySize();
if (lmem_size == 0) {
return;
}
const auto element_count = static_cast<u32>(Common::AlignUp(lmem_size, 4) / 4);
const Id type_array = TypeArray(t_float, Constant(t_uint, element_count));
const Id type_pointer = TypePointer(spv::StorageClass::Private, type_array);
Name(type_pointer, "LocalMemory");
local_memory =
OpVariable(type_pointer, spv::StorageClass::Private, ConstantNull(type_array));
AddGlobalVariable(Name(local_memory, "local_memory"));
}
void DeclareSharedMemory() {
if (stage != ShaderType::Compute) {
return;
}
t_smem_uint = TypePointer(spv::StorageClass::Workgroup, t_uint);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const u32 smem_size = specialization.shared_memory_size;
if (smem_size == 0) {
// Avoid declaring an empty array.
return;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const auto element_count = static_cast<u32>(Common::AlignUp(smem_size, 4) / 4);
const Id type_array = TypeArray(t_uint, Constant(t_uint, element_count));
const Id type_pointer = TypePointer(spv::StorageClass::Workgroup, type_array);
Name(type_pointer, "SharedMemory");
shared_memory = OpVariable(type_pointer, spv::StorageClass::Workgroup);
AddGlobalVariable(Name(shared_memory, "shared_memory"));
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
void DeclareInternalFlags() {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
constexpr std::array names = {"zero", "sign", "carry", "overflow"};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
for (std::size_t flag = 0; flag < INTERNAL_FLAGS_COUNT; ++flag) {
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
const auto flag_code = static_cast<InternalFlag>(flag);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
internal_flags[flag] = AddGlobalVariable(Name(id, names[flag]));
}
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
void DeclareInputVertexArray(u32 length) {
constexpr auto storage = spv::StorageClass::Input;
std::tie(in_indices, in_vertex) = DeclareVertexArray(storage, "in_indices", length);
}
void DeclareOutputVertexArray(u32 length) {
constexpr auto storage = spv::StorageClass::Output;
std::tie(out_indices, out_vertex) = DeclareVertexArray(storage, "out_indices", length);
}
std::tuple<VertexIndices, Id> DeclareVertexArray(spv::StorageClass storage_class,
std::string name, u32 length) {
const auto [struct_id, indices] = DeclareVertexStruct();
const Id vertex_array = TypeArray(struct_id, Constant(t_uint, length));
const Id vertex_ptr = TypePointer(storage_class, vertex_array);
const Id vertex = OpVariable(vertex_ptr, storage_class);
AddGlobalVariable(Name(vertex, std::move(name)));
interfaces.push_back(vertex);
return {indices, vertex};
}
void DeclareOutputVertex() {
Id out_vertex_struct;
std::tie(out_vertex_struct, out_indices) = DeclareVertexStruct();
const Id out_vertex_ptr = TypePointer(spv::StorageClass::Output, out_vertex_struct);
out_vertex = OpVariable(out_vertex_ptr, spv::StorageClass::Output);
interfaces.push_back(AddGlobalVariable(Name(out_vertex, "out_vertex")));
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
void DeclareInputAttributes() {
shader: Remove unused AbufNode Ipa mode
2019-04-30 04:37:09 +02:00
for (const auto index : ir.GetInputAttributes()) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
if (!IsGenericAttribute(index)) {
continue;
}
const u32 location = GetGenericAttributeLocation(index);
vk_rasterizer: Implement constant attributes Constant attributes (in OpenGL known disabled attributes) are not supported on Vulkan, even with extensions. To emulate this behavior we return zero on reads from disabled vertex attributes in shader code. This has no caching cost because attribute formats are not dynamic state on Vulkan and we have to store it in the pipeline cache anyway. - Fixes Animal Crossing: New Horizons terrain borders
2020-05-13 09:32:41 +02:00
if (!IsAttributeEnabled(location)) {
continue;
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const auto type_descriptor = GetAttributeType(location);
Id type;
if (IsInputAttributeArray()) {
type = GetTypeVectorDefinitionLut(type_descriptor.type).at(3);
type = TypeArray(type, Constant(t_uint, GetNumInputVertices()));
type = TypePointer(spv::StorageClass::Input, type);
} else {
type = type_descriptor.vector;
}
const Id id = OpVariable(type, spv::StorageClass::Input);
AddGlobalVariable(Name(id, fmt::format("in_attr{}", location)));
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
input_attributes.emplace(index, id);
interfaces.push_back(id);
Decorate(id, spv::Decoration::Location, location);
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
if (stage != ShaderType::Fragment) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
continue;
}
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
switch (header.ps.GetPixelImap(location)) {
case PixelImap::Constant:
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
Decorate(id, spv::Decoration::Flat);
break;
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
case PixelImap::Perspective:
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
// Default
break;
shader_decompiler: Remove FragCoord.w hack and change IPA implementation Credits go to gdkchan and Ryujinx. The pull request used for this can be found here: https://github.com/Ryujinx/Ryujinx/pull/1082 yuzu was already using the header for interpolation, but it was missing the FragCoord.w multiplication described in the linked pull request. This commit finally removes the FragCoord.w == 1.0f hack from the shader decompiler. While we are at it, this commit renames some enumerations to match Nvidia's documentation (linked below) and fixes component declaration order in the shader program header (z and w were swapped). https://github.com/NVIDIA/open-gpu-doc/blob/master/Shader-Program-Header/Shader-Program-Header.html
2020-04-02 02:37:32 +02:00
case PixelImap::ScreenLinear:
Decorate(id, spv::Decoration::NoPerspective);
break;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
default:
UNREACHABLE_MSG("Unused attribute being fetched");
}
}
}
void DeclareOutputAttributes() {
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
if (stage == ShaderType::Compute || stage == ShaderType::Fragment) {
return;
}
UNIMPLEMENTED_IF(registry.GetGraphicsInfo().tfb_enabled && stage != ShaderType::Vertex);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
for (const auto index : ir.GetOutputAttributes()) {
if (!IsGenericAttribute(index)) {
continue;
}
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
DeclareOutputAttribute(index);
}
}
void DeclareOutputAttribute(Attribute::Index index) {
static constexpr std::string_view swizzle = "xyzw";
const u32 location = GetGenericAttributeLocation(index);
u8 element = 0;
while (element < 4) {
const std::size_t remainder = 4 - element;
std::size_t num_components = remainder;
const std::optional tfb = GetTransformFeedbackInfo(index, element);
if (tfb) {
num_components = tfb->components;
}
Id type = GetTypeVectorDefinitionLut(Type::Float).at(num_components - 1);
vk_shader_decompiler: Fix default varying regression
2020-03-12 06:35:31 +01:00
Id varying_default = v_varying_default;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (IsOutputAttributeArray()) {
const u32 num = GetNumOutputVertices();
type = TypeArray(type, Constant(t_uint, num));
renderer_vulkan: Drop Vulkan-Hpp
2020-03-27 05:33:21 +01:00
if (device.GetDriverID() != VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
// Intel's proprietary driver fails to setup defaults for arrayed output
// attributes.
varying_default = ConstantComposite(type, std::vector(num, varying_default));
}
}
type = TypePointer(spv::StorageClass::Output, type);
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
std::string name = fmt::format("out_attr{}", location);
if (num_components < 4 || element > 0) {
name = fmt::format("{}_{}", name, swizzle.substr(element, num_components));
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id id = OpVariable(type, spv::StorageClass::Output, varying_default);
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
Name(AddGlobalVariable(id), name);
GenericVaryingDescription description;
description.id = id;
description.first_element = element;
description.is_scalar = num_components == 1;
for (u32 i = 0; i < num_components; ++i) {
const u8 offset = static_cast<u8>(static_cast<u32>(index) * 4 + element + i);
output_attributes.emplace(offset, description);
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
interfaces.push_back(id);
Decorate(id, spv::Decoration::Location, location);
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
if (element > 0) {
Decorate(id, spv::Decoration::Component, static_cast<u32>(element));
}
if (tfb && device.IsExtTransformFeedbackSupported()) {
Decorate(id, spv::Decoration::XfbBuffer, static_cast<u32>(tfb->buffer));
Decorate(id, spv::Decoration::XfbStride, static_cast<u32>(tfb->stride));
Decorate(id, spv::Decoration::Offset, static_cast<u32>(tfb->offset));
}
vk_shader_decompiler: fix linux build
2020-03-15 18:00:14 +01:00
element = static_cast<u8>(static_cast<std::size_t>(element) + num_components);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
}
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
std::optional<VaryingTFB> GetTransformFeedbackInfo(Attribute::Index index, u8 element = 0) {
vk_shader_decompiler: Fix implicit type conversion Co-Authored-By: Mat M. <mathew1800@gmail.com>
2020-03-10 00:08:48 +01:00
const u8 location = static_cast<u8>(static_cast<u32>(index) * 4 + element);
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
const auto it = transform_feedback.find(location);
if (it == transform_feedback.end()) {
return {};
}
return it->second;
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
u32 DeclareConstantBuffers(u32 binding) {
for (const auto& [index, size] : ir.GetConstantBuffers()) {
vk_device: Add miscellaneous features and minor style changes * Increase minimum Vulkan requirements * Require VK_EXT_vertex_attribute_divisor * Require depthClamp, samplerAnisotropy and largePoints features * Search and expose VK_KHR_uniform_buffer_standard_layout * Search and expose VK_EXT_index_type_uint8 * Search and expose native float16 arithmetics * Track current driver with VK_KHR_driver_properties * Query and expose SSBO alignment * Query more image formats * Improve logging overall * Minor style changes * Minor rephrasing of commentaries
2019-09-13 06:55:28 +02:00
const Id type = device.IsKhrUniformBufferStandardLayoutSupported() ? t_cbuf_scalar_ubo
: t_cbuf_std140_ubo;
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
const Id id = OpVariable(type, spv::StorageClass::Uniform);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
AddGlobalVariable(Name(id, fmt::format("cbuf_{}", index)));
Decorate(id, spv::Decoration::Binding, binding++);
Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
constant_buffers.emplace(index, id);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return binding;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
u32 DeclareGlobalBuffers(u32 binding) {
for (const auto& [base, usage] : ir.GetGlobalMemory()) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id id = OpVariable(t_gmem_ssbo, spv::StorageClass::StorageBuffer);
AddGlobalVariable(
shader_ir: Implement STG, keep track of global memory usage and flush
2019-02-07 04:05:41 +01:00
Name(id, fmt::format("gmem_{}_{}", base.cbuf_index, base.cbuf_offset)));
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
Decorate(id, spv::Decoration::Binding, binding++);
Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
shader_ir: Implement STG, keep track of global memory usage and flush
2019-02-07 04:05:41 +01:00
global_buffers.emplace(base, id);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return binding;
}
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
u32 DeclareUniformTexels(u32 binding) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
for (const auto& sampler : ir.GetSamplers()) {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (!sampler.is_buffer) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
continue;
}
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
ASSERT(!sampler.is_array);
ASSERT(!sampler.is_shadow);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
constexpr auto dim = spv::Dim::Buffer;
constexpr int depth = 0;
constexpr int arrayed = 0;
constexpr bool ms = false;
constexpr int sampled = 1;
constexpr auto format = spv::ImageFormat::Unknown;
const Id image_type = TypeImage(t_float, dim, depth, arrayed, ms, sampled, format);
const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, image_type);
const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant);
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
AddGlobalVariable(Name(id, fmt::format("sampler_{}", sampler.index)));
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Decorate(id, spv::Decoration::Binding, binding++);
Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
uniform_texels.emplace(sampler.index, TexelBuffer{image_type, id});
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
return binding;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
u32 DeclareSamplers(u32 binding) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
for (const auto& sampler : ir.GetSamplers()) {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (sampler.is_buffer) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
continue;
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const auto dim = GetSamplerDim(sampler);
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const int depth = sampler.is_shadow ? 1 : 0;
const int arrayed = sampler.is_array ? 1 : 0;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
constexpr bool ms = false;
constexpr int sampled = 1;
constexpr auto format = spv::ImageFormat::Unknown;
const Id image_type = TypeImage(t_float, dim, depth, arrayed, ms, sampled, format);
vk_shader_decompiler: Implement indexed textures Implement accessing textures through an index. It uses the same interface as OpenGL, the main difference is that Vulkan bindings are forced to be arrayed (the binding index doesn't change for stacked textures in SPIR-V).
2020-02-23 06:35:16 +01:00
const Id sampler_type = TypeSampledImage(image_type);
const Id sampler_pointer_type =
TypePointer(spv::StorageClass::UniformConstant, sampler_type);
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const Id type = sampler.is_indexed
? TypeArray(sampler_type, Constant(t_uint, sampler.size))
vk_shader_decompiler: Implement indexed textures Implement accessing textures through an index. It uses the same interface as OpenGL, the main difference is that Vulkan bindings are forced to be arrayed (the binding index doesn't change for stacked textures in SPIR-V).
2020-02-23 06:35:16 +01:00
: sampler_type;
const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, type);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant);
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
AddGlobalVariable(Name(id, fmt::format("sampler_{}", sampler.index)));
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Decorate(id, spv::Decoration::Binding, binding++);
Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
sampled_images.emplace(
sampler.index, SampledImage{image_type, sampler_type, sampler_pointer_type, id});
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
return binding;
}
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
u32 DeclareStorageTexels(u32 binding) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
for (const auto& image : ir.GetImages()) {
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
if (image.type != Tegra::Shader::ImageType::TextureBuffer) {
continue;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
DeclareImage(image, binding);
}
return binding;
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
u32 DeclareImages(u32 binding) {
for (const auto& image : ir.GetImages()) {
if (image.type == Tegra::Shader::ImageType::TextureBuffer) {
continue;
}
DeclareImage(image, binding);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return binding;
}
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
void DeclareImage(const Image& image, u32& binding) {
const auto [dim, arrayed] = GetImageDim(image);
constexpr int depth = 0;
constexpr bool ms = false;
constexpr int sampled = 2; // This won't be accessed with a sampler
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
const auto format = image.is_atomic ? spv::ImageFormat::R32ui : spv::ImageFormat::Unknown;
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
const Id image_type = TypeImage(t_uint, dim, depth, arrayed, ms, sampled, format, {});
const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, image_type);
const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant);
AddGlobalVariable(Name(id, fmt::format("image_{}", image.index)));
Decorate(id, spv::Decoration::Binding, binding++);
Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
if (image.is_read && !image.is_written) {
Decorate(id, spv::Decoration::NonWritable);
} else if (image.is_written && !image.is_read) {
Decorate(id, spv::Decoration::NonReadable);
}
images.emplace(image.index, StorageImage{image_type, id});
}
vk_shader_decompiler: Disable default values on unwritten render targets Some games like The Legend of Zelda: Breath of the Wild assign render targets without writing them from the fragment shader. This generates Vulkan validation errors, so silence these I previously introduced a commit to set "vec4(0, 0, 0, 1)" for these attachments. The problem is that this is not what games expect. This commit reverts that change.
2020-01-24 05:15:50 +01:00
bool IsRenderTargetEnabled(u32 rt) const {
for (u32 component = 0; component < 4; ++component) {
if (header.ps.IsColorComponentOutputEnabled(rt, component)) {
return true;
}
}
return false;
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
bool IsInputAttributeArray() const {
return stage == ShaderType::TesselationControl || stage == ShaderType::TesselationEval ||
stage == ShaderType::Geometry;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
bool IsOutputAttributeArray() const {
return stage == ShaderType::TesselationControl;
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_rasterizer: Implement constant attributes Constant attributes (in OpenGL known disabled attributes) are not supported on Vulkan, even with extensions. To emulate this behavior we return zero on reads from disabled vertex attributes in shader code. This has no caching cost because attribute formats are not dynamic state on Vulkan and we have to store it in the pipeline cache anyway. - Fixes Animal Crossing: New Horizons terrain borders
2020-05-13 09:32:41 +02:00
bool IsAttributeEnabled(u32 location) const {
return stage != ShaderType::Vertex || specialization.enabled_attributes[location];
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
u32 GetNumInputVertices() const {
switch (stage) {
case ShaderType::Geometry:
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
return GetNumPrimitiveTopologyVertices(registry.GetGraphicsInfo().primitive_topology);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case ShaderType::TesselationControl:
case ShaderType::TesselationEval:
return NumInputPatches;
default:
UNREACHABLE();
return 1;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
u32 GetNumOutputVertices() const {
switch (stage) {
case ShaderType::TesselationControl:
return header.common2.threads_per_input_primitive;
default:
UNREACHABLE();
return 1;
}
}
std::tuple<Id, VertexIndices> DeclareVertexStruct() {
struct BuiltIn {
Id type;
spv::BuiltIn builtin;
const char* name;
};
std::vector<BuiltIn> members;
members.reserve(4);
const auto AddBuiltIn = [&](Id type, spv::BuiltIn builtin, const char* name) {
const auto index = static_cast<u32>(members.size());
members.push_back(BuiltIn{type, builtin, name});
return index;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
VertexIndices indices;
indices.position = AddBuiltIn(t_float4, spv::BuiltIn::Position, "position");
vk_shader_decompiler: Implement Layer output attribute SPIR-V's Layer is GLSL's gl_Layer. It lets the application choose from a shader stage (vertex, tessellation or geometry) which framebuffer layer write the output fragments to.
2020-02-16 06:40:17 +01:00
if (ir.UsesLayer()) {
if (stage != ShaderType::Vertex || device.IsExtShaderViewportIndexLayerSupported()) {
indices.layer = AddBuiltIn(t_int, spv::BuiltIn::Layer, "layer");
} else {
LOG_ERROR(
Render_Vulkan,
"Shader requires Layer but it's not supported on this stage with this device.");
}
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (ir.UsesViewportIndex()) {
if (stage != ShaderType::Vertex || device.IsExtShaderViewportIndexLayerSupported()) {
indices.viewport = AddBuiltIn(t_int, spv::BuiltIn::ViewportIndex, "viewport_index");
} else {
vk_shader_decompiler: Implement Layer output attribute SPIR-V's Layer is GLSL's gl_Layer. It lets the application choose from a shader stage (vertex, tessellation or geometry) which framebuffer layer write the output fragments to.
2020-02-16 06:40:17 +01:00
LOG_ERROR(Render_Vulkan, "Shader requires ViewportIndex but it's not supported on "
"this stage with this device.");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
}
if (ir.UsesPointSize() || specialization.point_size) {
indices.point_size = AddBuiltIn(t_float, spv::BuiltIn::PointSize, "point_size");
}
const auto& output_attributes = ir.GetOutputAttributes();
const bool declare_clip_distances =
std::any_of(output_attributes.begin(), output_attributes.end(), [](const auto& index) {
return index == Attribute::Index::ClipDistances0123 ||
index == Attribute::Index::ClipDistances4567;
});
if (declare_clip_distances) {
indices.clip_distances = AddBuiltIn(TypeArray(t_float, Constant(t_uint, 8)),
spv::BuiltIn::ClipDistance, "clip_distances");
}
std::vector<Id> member_types;
member_types.reserve(members.size());
for (std::size_t i = 0; i < members.size(); ++i) {
member_types.push_back(members[i].type);
}
const Id per_vertex_struct = Name(TypeStruct(member_types), "PerVertex");
Decorate(per_vertex_struct, spv::Decoration::Block);
for (std::size_t index = 0; index < members.size(); ++index) {
const auto& member = members[index];
MemberName(per_vertex_struct, static_cast<u32>(index), member.name);
MemberDecorate(per_vertex_struct, static_cast<u32>(index), spv::Decoration::BuiltIn,
static_cast<u32>(member.builtin));
}
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {per_vertex_struct, indices};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
void VisitBasicBlock(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) {
vk_shader_decompiler: Don't assert for void returns Atomic instructions can be used without returning anything and this is valid code. Remove the assert.
2020-05-15 06:56:58 +02:00
Visit(node);
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
}
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Visit(const Node& node) {
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-05 03:44:06 +02:00
if (const auto operation = std::get_if<OperationNode>(&*node)) {
Shader_IR: Address Feedback
2020-01-04 19:40:57 +01:00
if (const auto amend_index = operation->GetAmendIndex()) {
[[maybe_unused]] const Type type = Visit(ir.GetAmendNode(*amend_index)).type;
Shader_IR: add the ability to amend code in the shader ir. This commit introduces a mechanism by which shader IR code can be amended and extended. This useful for track algorithms where certain information can derived from before the track such as indexes to array samplers.
2019-12-30 18:54:53 +01:00
ASSERT(type == Type::Void);
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
const auto operation_index = static_cast<std::size_t>(operation->GetCode());
const auto decompiler = operation_decompilers[operation_index];
if (decompiler == nullptr) {
UNREACHABLE_MSG("Operation decompiler {} not defined", operation_index);
}
return (this->*decompiler)(*operation);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto gpr = std::get_if<GprNode>(&*node)) {
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
const u32 index = gpr->GetIndex();
if (index == Register::ZeroIndex) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {v_float_zero, Type::Float};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {OpLoad(t_float, registers.at(index)), Type::Float};
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
if (const auto cv = std::get_if<CustomVarNode>(&*node)) {
const u32 index = cv->GetIndex();
return {OpLoad(t_float, custom_variables.at(index)), Type::Float};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto immediate = std::get_if<ImmediateNode>(&*node)) {
return {Constant(t_uint, immediate->GetValue()), Type::Uint};
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto predicate = std::get_if<PredicateNode>(&*node)) {
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
const auto value = [&]() -> Id {
switch (const auto index = predicate->GetIndex(); index) {
case Tegra::Shader::Pred::UnusedIndex:
return v_true;
case Tegra::Shader::Pred::NeverExecute:
return v_false;
default:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return OpLoad(t_bool, predicates.at(index));
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
}();
if (predicate->IsNegated()) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {OpLogicalNot(t_bool, value), Type::Bool};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {value, Type::Bool};
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto abuf = std::get_if<AbufNode>(&*node)) {
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
const auto attribute = abuf->GetIndex();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const u32 element = abuf->GetElement();
const auto& buffer = abuf->GetBuffer();
const auto ArrayPass = [&](Id pointer_type, Id composite, std::vector<u32> indices) {
std::vector<Id> members;
members.reserve(std::size(indices) + 1);
if (buffer && IsInputAttributeArray()) {
members.push_back(AsUint(Visit(buffer)));
}
for (const u32 index : indices) {
members.push_back(Constant(t_uint, index));
}
return OpAccessChain(pointer_type, composite, members);
};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
switch (attribute) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case Attribute::Index::Position: {
if (stage == ShaderType::Fragment) {
return {OpLoad(t_float, AccessElement(t_in_float, frag_coord, element)),
Type::Float};
}
vk_shader_decompiler: Fix build issues on old gcc versions
2019-12-10 04:55:21 +01:00
const std::vector elements = {in_indices.position.value(), element};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {OpLoad(t_float, ArrayPass(t_in_float, in_vertex, elements)), Type::Float};
}
case Attribute::Index::PointCoord: {
switch (element) {
case 0:
case 1:
return {OpCompositeExtract(t_float, OpLoad(t_float2, point_coord), element),
Type::Float};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
UNIMPLEMENTED_MSG("Unimplemented point coord element={}", element);
return {v_float_zero, Type::Float};
}
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01: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.
switch (element) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case 0:
case 1:
return {OpLoad(t_float, AccessElement(t_in_float, tess_coord, element)),
Type::Float};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
case 2:
vk_shader_decompiler: Fix vertex id and instance id Vulkan's VertexIndex and InstanceIndex don't match with hardware. This is because Nvidia implements gl_VertexID and gl_InstanceID. The math that relates these is: gl_VertexIndex = gl_BaseVertex + gl_VertexID gl_InstanceIndex = gl_InstanceIndex + gl_InstanceID To emulate it using what Vulkan's SPIR-V offers (the *Index variants) this commit substracts gl_Base* from gl_*Index to obtain the OpenGL and hardware's equivalent.
2020-02-14 00:25:28 +01:00
return {
OpISub(t_int, OpLoad(t_int, instance_index), OpLoad(t_int, base_instance)),
Type::Int};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
case 3:
vk_shader_decompiler: Fix vertex id and instance id Vulkan's VertexIndex and InstanceIndex don't match with hardware. This is because Nvidia implements gl_VertexID and gl_InstanceID. The math that relates these is: gl_VertexIndex = gl_BaseVertex + gl_VertexID gl_InstanceIndex = gl_InstanceIndex + gl_InstanceID To emulate it using what Vulkan's SPIR-V offers (the *Index variants) this commit substracts gl_Base* from gl_*Index to obtain the OpenGL and hardware's equivalent.
2020-02-14 00:25:28 +01:00
return {OpISub(t_int, OpLoad(t_int, vertex_index), OpLoad(t_int, base_vertex)),
Type::Int};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
UNIMPLEMENTED_MSG("Unmanaged TessCoordInstanceIDVertexID element={}", element);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {Constant(t_uint, 0U), Type::Uint};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01: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);
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
if (element == 3) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id is_front_facing = OpLoad(t_bool, front_facing);
const Id true_value = Constant(t_int, static_cast<s32>(-1));
const Id false_value = Constant(t_int, 0);
return {OpSelect(t_int, is_front_facing, true_value, false_value), Type::Int};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
UNIMPLEMENTED_MSG("Unmanaged FrontFacing element={}", element);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {v_float_zero, Type::Float};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
default:
vk_rasterizer: Implement constant attributes Constant attributes (in OpenGL known disabled attributes) are not supported on Vulkan, even with extensions. To emulate this behavior we return zero on reads from disabled vertex attributes in shader code. This has no caching cost because attribute formats are not dynamic state on Vulkan and we have to store it in the pipeline cache anyway. - Fixes Animal Crossing: New Horizons terrain borders
2020-05-13 09:32:41 +02:00
if (!IsGenericAttribute(attribute)) {
break;
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
vk_rasterizer: Implement constant attributes Constant attributes (in OpenGL known disabled attributes) are not supported on Vulkan, even with extensions. To emulate this behavior we return zero on reads from disabled vertex attributes in shader code. This has no caching cost because attribute formats are not dynamic state on Vulkan and we have to store it in the pipeline cache anyway. - Fixes Animal Crossing: New Horizons terrain borders
2020-05-13 09:32:41 +02:00
const u32 location = GetGenericAttributeLocation(attribute);
if (!IsAttributeEnabled(location)) {
// Disabled attributes (also known as constant attributes) always return zero.
return {v_float_zero, Type::Float};
}
const auto type_descriptor = GetAttributeType(location);
const Type type = type_descriptor.type;
const Id attribute_id = input_attributes.at(attribute);
const std::vector elements = {element};
const Id pointer = ArrayPass(type_descriptor.scalar, attribute_id, elements);
return {OpLoad(GetTypeDefinition(type), pointer), type};
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {v_float_zero, Type::Float};
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto cbuf = std::get_if<CbufNode>(&*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
const Node& offset = cbuf->GetOffset();
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
const Id buffer_id = constant_buffers.at(cbuf->GetIndex());
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
Id pointer{};
vk_device: Add miscellaneous features and minor style changes * Increase minimum Vulkan requirements * Require VK_EXT_vertex_attribute_divisor * Require depthClamp, samplerAnisotropy and largePoints features * Search and expose VK_KHR_uniform_buffer_standard_layout * Search and expose VK_EXT_index_type_uint8 * Search and expose native float16 arithmetics * Track current driver with VK_KHR_driver_properties * Query and expose SSBO alignment * Query more image formats * Improve logging overall * Minor style changes * Minor rephrasing of commentaries
2019-09-13 06:55:28 +02:00
if (device.IsKhrUniformBufferStandardLayoutSupported()) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id buffer_offset =
OpShiftRightLogical(t_uint, AsUint(Visit(offset)), Constant(t_uint, 2U));
pointer =
OpAccessChain(t_cbuf_float, buffer_id, Constant(t_uint, 0U), buffer_offset);
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
} else {
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
Id buffer_index{};
Id buffer_element{};
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)) {
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
// Direct access
const u32 offset_imm = immediate->GetValue();
ASSERT(offset_imm % 4 == 0);
buffer_index = Constant(t_uint, offset_imm / 16);
buffer_element = Constant(t_uint, (offset_imm / 4) % 4);
} else if (std::holds_alternative<OperationNode>(*offset)) {
// Indirect access
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id offset_id = AsUint(Visit(offset));
const Id unsafe_offset = OpUDiv(t_uint, offset_id, Constant(t_uint, 4));
const Id final_offset =
OpUMod(t_uint, unsafe_offset, Constant(t_uint, MaxConstBufferElements - 1));
buffer_index = OpUDiv(t_uint, final_offset, Constant(t_uint, 4));
buffer_element = OpUMod(t_uint, final_offset, Constant(t_uint, 4));
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
} else {
UNREACHABLE_MSG("Unmanaged offset node type");
}
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
pointer = OpAccessChain(t_cbuf_float, buffer_id, v_uint_zero, buffer_index,
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
buffer_element);
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {OpLoad(t_float, pointer), Type::Float};
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto gmem = std::get_if<GmemNode>(&*node)) {
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
return {OpLoad(t_uint, GetGlobalMemoryPointer(*gmem)), Type::Uint};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto lmem = std::get_if<LmemNode>(&*node)) {
Id address = AsUint(Visit(lmem->GetAddress()));
address = OpShiftRightLogical(t_uint, address, Constant(t_uint, 2U));
const Id pointer = OpAccessChain(t_prv_float, local_memory, address);
return {OpLoad(t_float, pointer), Type::Float};
}
if (const auto smem = std::get_if<SmemNode>(&*node)) {
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
return {OpLoad(t_uint, GetSharedMemoryPointer(*smem)), Type::Uint};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto internal_flag = std::get_if<InternalFlagNode>(&*node)) {
const Id flag = internal_flags.at(static_cast<std::size_t>(internal_flag->GetFlag()));
return {OpLoad(t_bool, flag), Type::Bool};
}
if (const auto conditional = std::get_if<ConditionalNode>(&*node)) {
Shader_IR: Address Feedback
2020-01-04 19:40:57 +01:00
if (const auto amend_index = conditional->GetAmendIndex()) {
[[maybe_unused]] const Type type = Visit(ir.GetAmendNode(*amend_index)).type;
Shader_IR: add the ability to amend code in the shader ir. This commit introduces a mechanism by which shader IR code can be amended and extended. This useful for track algorithms where certain information can derived from before the track such as indexes to array samplers.
2019-12-30 18:54:53 +01:00
ASSERT(type == Type::Void);
}
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
// It's invalid to call conditional on nested nodes, use an operation instead
const Id true_label = OpLabel();
const Id skip_label = OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id condition = AsBool(Visit(conditional->GetCondition()));
OpSelectionMerge(skip_label, spv::SelectionControlMask::MaskNone);
OpBranchConditional(condition, true_label, skip_label);
AddLabel(true_label);
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
conditional_branch_set = true;
inside_branch = false;
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
VisitBasicBlock(conditional->GetCode());
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
conditional_branch_set = false;
if (!inside_branch) {
OpBranch(skip_label);
vk_shader_decompiler: Correct Branches inside conditionals.
2019-09-25 20:34:08 +02:00
} else {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
inside_branch = false;
vk_shader_decompiler: Correct Branches inside conditionals.
2019-09-25 20:34:08 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddLabel(skip_label);
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
return {};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto comment = std::get_if<CommentNode>(&*node)) {
Name(OpUndef(t_void), comment->GetText());
vk_shader_decompiler: Implement Visit
2019-03-14 06:30:19 +01:00
return {};
}
UNREACHABLE();
return {};
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
template <Id (Module::*func)(Id, Id), Type result_type, Type type_a = result_type>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Unary(Operation operation) {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
const Id type_def = GetTypeDefinition(result_type);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id op_a = As(Visit(operation[0]), type_a);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id value = (this->*func)(type_def, op_a);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
if (IsPrecise(operation)) {
Decorate(value, spv::Decoration::NoContraction);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {value, result_type};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
template <Id (Module::*func)(Id, Id, Id), Type result_type, Type type_a = result_type,
Type type_b = type_a>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Binary(Operation operation) {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
const Id type_def = GetTypeDefinition(result_type);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id op_a = As(Visit(operation[0]), type_a);
const Id op_b = As(Visit(operation[1]), type_b);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id value = (this->*func)(type_def, op_a, op_b);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
if (IsPrecise(operation)) {
Decorate(value, spv::Decoration::NoContraction);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {value, result_type};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
template <Id (Module::*func)(Id, Id, Id, Id), Type result_type, Type type_a = result_type,
Type type_b = type_a, Type type_c = type_b>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Ternary(Operation operation) {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
const Id type_def = GetTypeDefinition(result_type);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id op_a = As(Visit(operation[0]), type_a);
const Id op_b = As(Visit(operation[1]), type_b);
const Id op_c = As(Visit(operation[2]), type_c);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id value = (this->*func)(type_def, op_a, op_b, op_c);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
if (IsPrecise(operation)) {
Decorate(value, spv::Decoration::NoContraction);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {value, result_type};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
template <Id (Module::*func)(Id, Id, Id, Id, Id), Type result_type, Type type_a = result_type,
Type type_b = type_a, Type type_c = type_b, Type type_d = type_c>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Quaternary(Operation operation) {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
const Id type_def = GetTypeDefinition(result_type);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id op_a = As(Visit(operation[0]), type_a);
const Id op_b = As(Visit(operation[1]), type_b);
const Id op_c = As(Visit(operation[2]), type_c);
const Id op_d = As(Visit(operation[3]), type_d);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id value = (this->*func)(type_def, op_a, op_b, op_c, op_d);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
if (IsPrecise(operation)) {
Decorate(value, spv::Decoration::NoContraction);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {value, result_type};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01: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];
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01: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)) {
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
if (gpr->GetIndex() == Register::ZeroIndex) {
shader_decompiler: Visit source nodes even when they assign to RZ Some operations like atomicMin were ignored because they returned were being stored to RZ. This operations have a side effect and it was being ignored.
2020-05-15 02:26:37 +02:00
// Writing to Register::ZeroIndex is a no op but we still have to visit its source
// because it might have side effects.
Visit(src);
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
target = {registers.at(gpr->GetIndex()), Type::Float};
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +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
} else if (const auto abuf = std::get_if<AbufNode>(&*dest)) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const auto& buffer = abuf->GetBuffer();
const auto ArrayPass = [&](Id pointer_type, Id composite, std::vector<u32> indices) {
std::vector<Id> members;
members.reserve(std::size(indices) + 1);
if (buffer && IsOutputAttributeArray()) {
members.push_back(AsUint(Visit(buffer)));
}
for (const u32 index : indices) {
members.push_back(Constant(t_uint, index));
}
return OpAccessChain(pointer_type, composite, members);
};
target = [&]() -> Expression {
const u32 element = abuf->GetElement();
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
switch (const auto attribute = abuf->GetIndex(); attribute) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case Attribute::Index::Position: {
const u32 index = out_indices.position.value();
return {ArrayPass(t_out_float, out_vertex, {index, element}), Type::Float};
}
gl_shader_decompiler: Implement gl_ViewportIndex and gl_Layer in vertex shaders This commit implements gl_ViewportIndex and gl_Layer in vertex and geometry shaders. In the case it's used in a vertex shader, it requires ARB_shader_viewport_layer_array. This extension is available on AMD and Nvidia devices (mesa and proprietary drivers), but not available on Intel on any platform. At the moment of writing this description I don't know if this is a hardware limitation or a driver limitation. In the case that ARB_shader_viewport_layer_array is not available, writes to these registers on a vertex shader are ignored, with the appropriate logging.
2019-07-08 01:36:42 +02:00
case Attribute::Index::LayerViewportPointSize:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
switch (element) {
vk_shader_decompiler: Implement Layer output attribute SPIR-V's Layer is GLSL's gl_Layer. It lets the application choose from a shader stage (vertex, tessellation or geometry) which framebuffer layer write the output fragments to.
2020-02-16 06:40:17 +01:00
case 1: {
if (!out_indices.layer) {
return {};
}
const u32 index = out_indices.layer.value();
return {AccessElement(t_out_int, out_vertex, index), Type::Int};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case 2: {
if (!out_indices.viewport) {
return {};
}
const u32 index = out_indices.viewport.value();
return {AccessElement(t_out_int, out_vertex, index), Type::Int};
}
case 3: {
const auto index = out_indices.point_size.value();
return {AccessElement(t_out_float, out_vertex, index), Type::Float};
}
default:
UNIMPLEMENTED_MSG("LayerViewportPoint element={}", abuf->GetElement());
return {};
}
case Attribute::Index::ClipDistances0123: {
const u32 index = out_indices.clip_distances.value();
return {AccessElement(t_out_float, out_vertex, index, element), Type::Float};
}
case Attribute::Index::ClipDistances4567: {
const u32 index = out_indices.clip_distances.value();
return {AccessElement(t_out_float, out_vertex, index, element + 4),
Type::Float};
}
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
default:
if (IsGenericAttribute(attribute)) {
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
const u8 offset = static_cast<u8>(static_cast<u8>(attribute) * 4 + element);
const GenericVaryingDescription description = output_attributes.at(offset);
const Id composite = description.id;
std::vector<u32> indices;
if (!description.is_scalar) {
indices.push_back(element - description.first_element);
}
return {ArrayPass(t_out_float, composite, indices), Type::Float};
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
}
UNIMPLEMENTED_MSG("Unhandled output attribute: {}",
static_cast<u32>(attribute));
return {};
}
}();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
} else if (const auto patch = std::get_if<PatchNode>(&*dest)) {
target = [&]() -> Expression {
const u32 offset = patch->GetOffset();
switch (offset) {
case 0:
case 1:
case 2:
case 3:
return {AccessElement(t_out_float, tess_level_outer, offset % 4), Type::Float};
case 4:
case 5:
return {AccessElement(t_out_float, tess_level_inner, offset % 4), Type::Float};
}
UNIMPLEMENTED_MSG("Unhandled patch output offset: {}", offset);
return {};
}();
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)) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id address = AsUint(Visit(lmem->GetAddress()));
address = OpUDiv(t_uint, address, Constant(t_uint, 4));
target = {OpAccessChain(t_prv_float, local_memory, address), Type::Float};
} else if (const auto smem = std::get_if<SmemNode>(&*dest)) {
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
target = {GetSharedMemoryPointer(*smem), Type::Uint};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
} else if (const auto gmem = std::get_if<GmemNode>(&*dest)) {
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
target = {GetGlobalMemoryPointer(*gmem), Type::Uint};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Shader_IR: Correct Custom Variable assignment.
2020-01-07 23:56:03 +01:00
} else if (const auto cv = std::get_if<CustomVarNode>(&*dest)) {
target = {custom_variables.at(cv->GetIndex()), Type::Float};
Shader_IR: Address feedback.
2020-01-24 15:44:34 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
} else {
UNIMPLEMENTED();
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
}
vk_shader_decompiler: Implement Layer output attribute SPIR-V's Layer is GLSL's gl_Layer. It lets the application choose from a shader stage (vertex, tessellation or geometry) which framebuffer layer write the output fragments to.
2020-02-16 06:40:17 +01:00
if (!target.id) {
// On failure we return a nullptr target.id, skip these stores.
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpStore(target.id, As(Visit(src), target.type));
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
template <u32 offset>
Expression FCastHalf(Operation operation) {
const Id value = AsHalfFloat(Visit(operation[0]));
return {GetFloatFromHalfScalar(OpCompositeExtract(t_scalar_half, value, offset)),
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
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression FSwizzleAdd(Operation operation) {
const Id minus = Constant(t_float, -1.0f);
const Id plus = v_float_one;
const Id zero = v_float_zero;
const Id lut_a = ConstantComposite(t_float4, minus, plus, minus, zero);
const Id lut_b = ConstantComposite(t_float4, minus, minus, plus, minus);
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
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id mask = OpLoad(t_uint, thread_id);
mask = OpBitwiseAnd(t_uint, mask, Constant(t_uint, 3));
mask = OpShiftLeftLogical(t_uint, mask, Constant(t_uint, 1));
mask = OpShiftRightLogical(t_uint, AsUint(Visit(operation[2])), mask);
mask = OpBitwiseAnd(t_uint, mask, Constant(t_uint, 3));
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id modifier_a = OpVectorExtractDynamic(t_float, lut_a, mask);
const Id modifier_b = OpVectorExtractDynamic(t_float, lut_b, mask);
const Id op_a = OpFMul(t_float, AsFloat(Visit(operation[0])), modifier_a);
const Id op_b = OpFMul(t_float, AsFloat(Visit(operation[1])), modifier_b);
return {OpFAdd(t_float, op_a, op_b), Type::Float};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression HNegate(Operation operation) {
const bool is_f16 = device.IsFloat16Supported();
const Id minus_one = Constant(t_scalar_half, is_f16 ? 0xbc00 : 0xbf800000);
const Id one = Constant(t_scalar_half, is_f16 ? 0x3c00 : 0x3f800000);
const auto GetNegate = [&](std::size_t index) {
return OpSelect(t_scalar_half, AsBool(Visit(operation[index])), minus_one, one);
};
const Id negation = OpCompositeConstruct(t_half, GetNegate(1), GetNegate(2));
return {OpFMul(t_half, AsHalfFloat(Visit(operation[0])), negation), Type::HalfFloat};
shader_ir/decode: Implement half float saturation
2019-04-09 23:41:41 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression HClamp(Operation operation) {
const auto Pack = [&](std::size_t index) {
const Id scalar = GetHalfScalarFromFloat(AsFloat(Visit(operation[index])));
return OpCompositeConstruct(t_half, scalar, scalar);
};
const Id value = AsHalfFloat(Visit(operation[0]));
const Id min = Pack(1);
const Id max = Pack(2);
const Id clamped = OpFClamp(t_half, value, min, max);
if (IsPrecise(operation)) {
Decorate(clamped, spv::Decoration::NoContraction);
}
return {clamped, Type::HalfFloat};
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
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression HCastFloat(Operation operation) {
const Id value = GetHalfScalarFromFloat(AsFloat(Visit(operation[0])));
return {OpCompositeConstruct(t_half, value, Constant(t_scalar_half, 0)), Type::HalfFloat};
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
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression HUnpack(Operation operation) {
Expression operand = Visit(operation[0]);
const auto type = std::get<Tegra::Shader::HalfType>(operation.GetMeta());
if (type == Tegra::Shader::HalfType::H0_H1) {
return operand;
}
const auto value = [&] {
switch (std::get<Tegra::Shader::HalfType>(operation.GetMeta())) {
case Tegra::Shader::HalfType::F32:
return GetHalfScalarFromFloat(AsFloat(operand));
case Tegra::Shader::HalfType::H0_H0:
return OpCompositeExtract(t_scalar_half, AsHalfFloat(operand), 0);
case Tegra::Shader::HalfType::H1_H1:
return OpCompositeExtract(t_scalar_half, AsHalfFloat(operand), 1);
default:
UNREACHABLE();
return ConstantNull(t_half);
}
}();
return {OpCompositeConstruct(t_half, value, value), Type::HalfFloat};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression HMergeF32(Operation operation) {
const Id value = AsHalfFloat(Visit(operation[0]));
return {GetFloatFromHalfScalar(OpCompositeExtract(t_scalar_half, value, 0)), Type::Float};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
template <u32 offset>
Expression HMergeHN(Operation operation) {
const Id target = AsHalfFloat(Visit(operation[0]));
const Id source = AsHalfFloat(Visit(operation[1]));
const Id object = OpCompositeExtract(t_scalar_half, source, offset);
return {OpCompositeInsert(t_half, object, target, offset), Type::HalfFloat};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression HPack2(Operation operation) {
const Id low = GetHalfScalarFromFloat(AsFloat(Visit(operation[0])));
const Id high = GetHalfScalarFromFloat(AsFloat(Visit(operation[1])));
return {OpCompositeConstruct(t_half, low, high), Type::HalfFloat};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
shader/arithmetic_integer: Implement CC for IADD
2020-04-26 02:56:11 +02:00
Expression LogicalAddCarry(Operation operation) {
const Id op_a = AsUint(Visit(operation[0]));
const Id op_b = AsUint(Visit(operation[1]));
const Id result = OpIAddCarry(TypeStruct({t_uint, t_uint}), op_a, op_b);
const Id carry = OpCompositeExtract(t_uint, result, 1);
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
return {OpINotEqual(t_bool, carry, v_uint_zero), Type::Bool};
shader/arithmetic_integer: Implement CC for IADD
2020-04-26 02:56:11 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01: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];
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
Id 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)) {
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +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 = predicates.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
} else if (const auto flag = std::get_if<InternalFlagNode>(&*dest)) {
vk_shader_decompiler: Implement Assign and LogicalAssign
2019-03-14 06:44:23 +01:00
target = internal_flags.at(static_cast<u32>(flag->GetFlag()));
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpStore(target, AsBool(Visit(src)));
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
Expression LogicalFOrdered(Operation operation) {
// Emulate SPIR-V's OpOrdered
const Id op_a = AsFloat(Visit(operation[0]));
const Id op_b = AsFloat(Visit(operation[1]));
const Id is_num_a = OpFOrdEqual(t_bool, op_a, op_a);
const Id is_num_b = OpFOrdEqual(t_bool, op_b, op_b);
return {OpLogicalAnd(t_bool, is_num_a, is_num_b), Type::Bool};
}
Expression LogicalFUnordered(Operation operation) {
// Emulate SPIR-V's OpUnordered
const Id op_a = AsFloat(Visit(operation[0]));
const Id op_b = AsFloat(Visit(operation[1]));
const Id is_nan_a = OpIsNan(t_bool, op_a);
const Id is_nan_b = OpIsNan(t_bool, op_b);
return {OpLogicalOr(t_bool, is_nan_a, is_nan_b), Type::Bool};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id GetTextureSampler(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
ASSERT(!meta.sampler.is_buffer);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const auto& entry = sampled_images.at(meta.sampler.index);
vk_shader_decompiler: Implement indexed textures Implement accessing textures through an index. It uses the same interface as OpenGL, the main difference is that Vulkan bindings are forced to be arrayed (the binding index doesn't change for stacked textures in SPIR-V).
2020-02-23 06:35:16 +01:00
Id sampler = entry.variable;
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta.sampler.is_indexed) {
vk_shader_decompiler: Implement indexed textures Implement accessing textures through an index. It uses the same interface as OpenGL, the main difference is that Vulkan bindings are forced to be arrayed (the binding index doesn't change for stacked textures in SPIR-V).
2020-02-23 06:35:16 +01:00
const Id index = AsInt(Visit(meta.index));
sampler = OpAccessChain(entry.sampler_pointer_type, sampler, index);
}
return OpLoad(entry.sampler_type, sampler);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id GetTextureImage(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const u32 index = meta.sampler.index;
if (meta.sampler.is_buffer) {
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
const auto& entry = uniform_texels.at(index);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return OpLoad(entry.image_type, entry.image);
} else {
const auto& entry = sampled_images.at(index);
return OpImage(entry.image_type, GetTextureSampler(operation));
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id GetImage(Operation operation) {
const auto& meta = std::get<MetaImage>(operation.GetMeta());
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const auto entry = images.at(meta.image.index);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return OpLoad(entry.image_type, entry.image);
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id AssembleVector(const std::vector<Id>& coords, Type type) {
const Id coords_type = GetTypeVectorDefinitionLut(type).at(coords.size() - 1);
return coords.size() == 1 ? coords[0] : OpCompositeConstruct(coords_type, coords);
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id GetCoordinates(Operation operation, Type type) {
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
std::vector<Id> coords;
for (std::size_t i = 0; i < operation.GetOperandsCount(); ++i) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
coords.push_back(As(Visit(operation[i]), type));
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (const auto meta = std::get_if<MetaTexture>(&operation.GetMeta())) {
// Add array coordinate for textures
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta->sampler.is_array) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id array = AsInt(Visit(meta->array));
if (type == Type::Float) {
array = OpConvertSToF(t_float, array);
}
coords.push_back(array);
}
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AssembleVector(coords, type);
}
Id GetOffsetCoordinates(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
std::vector<Id> coords;
coords.reserve(meta.aoffi.size());
for (const auto& coord : meta.aoffi) {
coords.push_back(AsInt(Visit(coord)));
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AssembleVector(coords, Type::Int);
}
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
std::pair<Id, Id> GetDerivatives(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
const auto& derivatives = meta.derivates;
ASSERT(derivatives.size() % 2 == 0);
const std::size_t components = derivatives.size() / 2;
std::vector<Id> dx, dy;
dx.reserve(components);
dy.reserve(components);
for (std::size_t index = 0; index < components; ++index) {
dx.push_back(AsFloat(Visit(derivatives.at(index * 2 + 0))));
dy.push_back(AsFloat(Visit(derivatives.at(index * 2 + 1))));
}
return {AssembleVector(dx, Type::Float), AssembleVector(dy, Type::Float)};
vk_shader_decompiler: Implement texture decompilation helper functions
2019-03-14 06:45:51 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression GetTextureElement(Operation operation, Id sample_value, Type type) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
const auto type_def = GetTypeDefinition(type);
return {OpCompositeExtract(type_def, sample_value, meta.element), type};
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Texture(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
const bool can_implicit = stage == ShaderType::Fragment;
const Id sampler = GetTextureSampler(operation);
const Id coords = GetCoordinates(operation, Type::Float);
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
std::vector<Id> operands;
spv::ImageOperandsMask mask{};
if (meta.bias) {
mask = mask | spv::ImageOperandsMask::Bias;
operands.push_back(AsFloat(Visit(meta.bias)));
}
if (!can_implicit) {
mask = mask | spv::ImageOperandsMask::Lod;
operands.push_back(v_float_zero);
}
if (!meta.aoffi.empty()) {
mask = mask | spv::ImageOperandsMask::Offset;
operands.push_back(GetOffsetCoordinates(operation));
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (meta.depth_compare) {
// Depth sampling
UNIMPLEMENTED_IF(meta.bias);
const Id dref = AsFloat(Visit(meta.depth_compare));
if (can_implicit) {
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
return {
OpImageSampleDrefImplicitLod(t_float, sampler, coords, dref, mask, operands),
Type::Float};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
} else {
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
return {
OpImageSampleDrefExplicitLod(t_float, sampler, coords, dref, mask, operands),
Type::Float};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
}
Id texture;
if (can_implicit) {
texture = OpImageSampleImplicitLod(t_float4, sampler, coords, mask, operands);
} else {
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
texture = OpImageSampleExplicitLod(t_float4, sampler, coords, mask, operands);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
return GetTextureElement(operation, texture, Type::Float);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression TextureLod(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
const Id sampler = GetTextureSampler(operation);
const Id coords = GetCoordinates(operation, Type::Float);
const Id lod = AsFloat(Visit(meta.lod));
spv::ImageOperandsMask mask = spv::ImageOperandsMask::Lod;
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
std::vector<Id> operands{lod};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (!meta.aoffi.empty()) {
mask = mask | spv::ImageOperandsMask::Offset;
operands.push_back(GetOffsetCoordinates(operation));
}
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta.sampler.is_shadow) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id dref = AsFloat(Visit(meta.depth_compare));
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
return {OpImageSampleDrefExplicitLod(t_float, sampler, coords, dref, mask, operands),
Type::Float};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
const Id texture = OpImageSampleExplicitLod(t_float4, sampler, coords, mask, operands);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return GetTextureElement(operation, texture, Type::Float);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression TextureGather(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
UNIMPLEMENTED_IF(!meta.aoffi.empty());
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id coords = GetCoordinates(operation, Type::Float);
Id texture{};
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta.sampler.is_shadow) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
texture = OpImageDrefGather(t_float4, GetTextureSampler(operation), coords,
AsFloat(Visit(meta.depth_compare)));
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
} else {
u32 component_value = 0;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (meta.component) {
const auto component = std::get_if<ImmediateNode>(&*meta.component);
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
ASSERT_MSG(component, "Component is not an immediate value");
component_value = component->GetValue();
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
texture = OpImageGather(t_float4, GetTextureSampler(operation), coords,
Constant(t_uint, component_value));
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return GetTextureElement(operation, texture, Type::Float);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression TextureQueryDimensions(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
UNIMPLEMENTED_IF(!meta.aoffi.empty());
UNIMPLEMENTED_IF(meta.depth_compare);
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const auto image_id = GetTextureImage(operation);
if (meta.element == 3) {
return {OpImageQueryLevels(t_int, image_id), Type::Int};
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id lod = AsUint(Visit(operation[0]));
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
const std::size_t coords_count = [&meta] {
switch (const auto type = meta.sampler.type) {
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
case Tegra::Shader::TextureType::Texture1D:
return 1;
case Tegra::Shader::TextureType::Texture2D:
case Tegra::Shader::TextureType::TextureCube:
return 2;
case Tegra::Shader::TextureType::Texture3D:
return 3;
default:
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
UNREACHABLE_MSG("Invalid texture type={}", static_cast<int>(type));
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
return 2;
}
}();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (meta.element >= coords_count) {
return {v_float_zero, Type::Float};
vk_shader_decompiler: Implement most common texture primitives
2019-03-14 06:47:09 +01:00
}
const std::array<Id, 3> types = {t_int, t_int2, t_int3};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id sizes = OpImageQuerySizeLod(types.at(coords_count - 1), image_id, lod);
const Id size = OpCompositeExtract(t_int, sizes, meta.element);
return {size, Type::Int};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression TextureQueryLod(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
UNIMPLEMENTED_IF(!meta.aoffi.empty());
UNIMPLEMENTED_IF(meta.depth_compare);
if (meta.element >= 2) {
UNREACHABLE_MSG("Invalid element");
return {v_float_zero, Type::Float};
}
const auto sampler_id = GetTextureSampler(operation);
const Id multiplier = Constant(t_float, 256.0f);
const Id multipliers = ConstantComposite(t_float2, multiplier, multiplier);
const Id coords = GetCoordinates(operation, Type::Float);
Id size = OpImageQueryLod(t_float2, sampler_id, coords);
size = OpFMul(t_float2, size, multipliers);
size = OpConvertFToS(t_int2, size);
return GetTextureElement(operation, size, Type::Int);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression TexelFetch(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
UNIMPLEMENTED_IF(meta.depth_compare);
const Id image = GetTextureImage(operation);
const Id coords = GetCoordinates(operation, Type::Int);
Id fetch;
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (meta.lod && !meta.sampler.is_buffer) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
fetch = OpImageFetch(t_float4, image, coords, spv::ImageOperandsMask::Lod,
AsInt(Visit(meta.lod)));
} else {
fetch = OpImageFetch(t_float4, image, coords);
}
return GetTextureElement(operation, fetch, Type::Float);
}
Expression TextureGradient(Operation operation) {
const auto& meta = std::get<MetaTexture>(operation.GetMeta());
UNIMPLEMENTED_IF(!meta.aoffi.empty());
const Id sampler = GetTextureSampler(operation);
const Id coords = GetCoordinates(operation, Type::Float);
const auto [dx, dy] = GetDerivatives(operation);
const std::vector grad = {dx, dy};
static constexpr auto mask = spv::ImageOperandsMask::Grad;
vk_shader_decompiler: Update sirit and implement Texture AOFFI
2019-12-19 05:41:22 +01:00
const Id texture = OpImageSampleExplicitLod(t_float4, sampler, coords, mask, grad);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return GetTextureElement(operation, texture, Type::Float);
}
Expression ImageLoad(Operation operation) {
vk_device: Shrink formatless capability name size
2020-03-06 09:06:02 +01:00
if (!device.IsFormatlessImageLoadSupported()) {
shader_decompiler: add check in case of device not support ShaderStorageImageReadWithoutFormat
2020-02-19 06:57:22 +01:00
return {v_float_zero, Type::Float};
}
vk_shader: Implement function ImageLoad (Used by Kirby Start Allies) Please enter the commit message for your changes. Lines starting
2020-02-18 15:34:01 +01:00
const auto& meta{std::get<MetaImage>(operation.GetMeta())};
const Id coords = GetCoordinates(operation, Type::Int);
const Id texel = OpImageRead(t_uint4, GetImage(operation), coords);
return {OpCompositeExtract(t_uint, texel, meta.element), Type::Uint};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression ImageStore(Operation operation) {
const auto meta{std::get<MetaImage>(operation.GetMeta())};
std::vector<Id> colors;
for (const auto& value : meta.values) {
colors.push_back(AsUint(Visit(value)));
}
const Id coords = GetCoordinates(operation, Type::Int);
const Id texel = OpCompositeConstruct(t_uint4, colors);
OpImageWrite(GetImage(operation), coords, texel, {});
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
return {};
}
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
template <Id (Module::*func)(Id, Id, Id, Id, Id)>
Expression AtomicImage(Operation operation) {
const auto& meta{std::get<MetaImage>(operation.GetMeta())};
ASSERT(meta.values.size() == 1);
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
const Id coordinate = GetCoordinates(operation, Type::Int);
const Id image = images.at(meta.image.index).image;
const Id sample = v_uint_zero;
const Id pointer = OpImageTexelPointer(t_image_uint, image, coordinate, sample);
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
const Id scope = Constant(t_uint, static_cast<u32>(spv::Scope::Device));
const Id semantics = v_uint_zero;
const Id value = AsUint(Visit(meta.values[0]));
return {(this->*func)(t_uint, pointer, scope, semantics, value), Type::Uint};
shader/image: Implement SUATOM and fix SUST
2019-07-18 02:03:53 +02:00
}
shader/memory: Implement RED.E.ADD Implements a reduction operation. It's an atomic operation that doesn't return a value. This commit introduces another primitive because some shading languages might have a primitive for reduction operations.
2020-04-06 07:24:47 +02:00
template <Id (Module::*func)(Id, Id, Id, Id, Id)>
vk_decompiler: add atomic op and handler function.
2020-03-13 17:08:04 +01:00
Expression Atomic(Operation operation) {
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
Id pointer;
if (const auto smem = std::get_if<SmemNode>(&*operation[0])) {
pointer = GetSharedMemoryPointer(*smem);
} else if (const auto gmem = std::get_if<GmemNode>(&*operation[0])) {
pointer = GetGlobalMemoryPointer(*gmem);
} else {
UNREACHABLE();
shader/memory: Implement RED.E.ADD Implements a reduction operation. It's an atomic operation that doesn't return a value. This commit introduces another primitive because some shading languages might have a primitive for reduction operations.
2020-04-06 07:24:47 +02:00
return {v_float_zero, Type::Float};
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
}
vk_shader_decompiler: Implement UAtomicAdd (ATOMS) on SPIR-V Also updates sirit to include atomic instructions.
2020-01-19 20:37:39 +01:00
const Id scope = Constant(t_uint, static_cast<u32>(spv::Scope::Device));
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
const Id semantics = v_uint_zero;
shader/memory: Implement RED.E.ADD Implements a reduction operation. It's an atomic operation that doesn't return a value. This commit introduces another primitive because some shading languages might have a primitive for reduction operations.
2020-04-06 07:24:47 +02:00
const Id value = AsUint(Visit(operation[1]));
return {(this->*func)(t_uint, pointer, scope, semantics, value), Type::Uint};
}
vk_shader_decompiler: Implement UAtomicAdd (ATOMS) on SPIR-V Also updates sirit to include atomic instructions.
2020-01-19 20:37:39 +01:00
shader/memory: Implement RED.E.ADD Implements a reduction operation. It's an atomic operation that doesn't return a value. This commit introduces another primitive because some shading languages might have a primitive for reduction operations.
2020-04-06 07:24:47 +02:00
template <Id (Module::*func)(Id, Id, Id, Id, Id)>
Expression Reduce(Operation operation) {
Atomic<func>(operation);
return {};
shader/memory: Implement ATOMS.ADD.U32
2020-01-16 08:00:52 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Branch(Operation operation) {
const auto& target = std::get<ImmediateNode>(*operation[0]);
OpStore(jmp_to, Constant(t_uint, target.GetValue()));
OpBranch(continue_label);
inside_branch = true;
if (!conditional_branch_set) {
AddLabel();
vk_shader_compiler: Don't enclose branches with if(true) to avoid crashing AMD
2019-09-23 02:15:09 +02:00
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression BranchIndirect(Operation operation) {
const Id op_a = AsUint(Visit(operation[0]));
shader_ir: Implement BRX & BRA.CC
2019-06-25 03:25:38 +02:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpStore(jmp_to, op_a);
OpBranch(continue_label);
inside_branch = true;
if (!conditional_branch_set) {
AddLabel();
vk_shader_compiler: Don't enclose branches with if(true) to avoid crashing AMD
2019-09-23 02:15:09 +02:00
}
shader_ir: Implement BRX & BRA.CC
2019-06-25 03:25:38 +02:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression PushFlowStack(Operation operation) {
const auto& target = std::get<ImmediateNode>(*operation[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
const auto [flow_stack, flow_stack_top] = GetFlowStack(operation);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id current = OpLoad(t_uint, flow_stack_top);
const Id next = OpIAdd(t_uint, current, Constant(t_uint, 1));
const Id access = OpAccessChain(t_func_uint, flow_stack, current);
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpStore(access, Constant(t_uint, target.GetValue()));
OpStore(flow_stack_top, next);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01: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 [flow_stack, flow_stack_top] = GetFlowStack(operation);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id current = OpLoad(t_uint, flow_stack_top);
const Id previous = OpISub(t_uint, current, Constant(t_uint, 1));
const Id access = OpAccessChain(t_func_uint, flow_stack, previous);
const Id target = OpLoad(t_uint, access);
OpStore(flow_stack_top, previous);
OpStore(jmp_to, target);
OpBranch(continue_label);
inside_branch = true;
if (!conditional_branch_set) {
AddLabel();
vk_shader_compiler: Don't enclose branches with if(true) to avoid crashing AMD
2019-09-23 02:15:09 +02:00
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
void PreExit() {
vk_shader_decompiler: Skip NDC correction when it is native Avoid changing gl_Position when the NDC used by the game is [0, 1] (Vulkan's native).
2019-12-19 05:45:09 +01:00
if (stage == ShaderType::Vertex && specialization.ndc_minus_one_to_one) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const u32 position_index = out_indices.position.value();
const Id z_pointer = AccessElement(t_out_float, out_vertex, position_index, 2U);
const Id w_pointer = AccessElement(t_out_float, out_vertex, position_index, 3U);
Id depth = OpLoad(t_float, z_pointer);
depth = OpFAdd(t_float, depth, OpLoad(t_float, w_pointer));
depth = OpFMul(t_float, depth, Constant(t_float, 0.5f));
OpStore(z_pointer, depth);
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (stage == ShaderType::Fragment) {
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
const auto SafeGetRegister = [&](u32 reg) {
// TODO(Rodrigo): Replace with contains once C++20 releases
if (const auto it = registers.find(reg); it != registers.end()) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return OpLoad(t_float, it->second);
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return v_float_zero;
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
};
UNIMPLEMENTED_IF_MSG(header.ps.omap.sample_mask != 0,
"Sample mask write is unimplemented");
// TODO(Rodrigo): Alpha testing
// Write the color outputs using the data in the shader registers, disabled
// rendertargets/components are skipped in the register assignment.
u32 current_reg = 0;
for (u32 rt = 0; rt < Maxwell::NumRenderTargets; ++rt) {
// TODO(Subv): Figure out how dual-source blending is configured in the Switch.
for (u32 component = 0; component < 4; ++component) {
vk_shader_decompiler: Disable default values on unwritten render targets Some games like The Legend of Zelda: Breath of the Wild assign render targets without writing them from the fragment shader. This generates Vulkan validation errors, so silence these I previously introduced a commit to set "vec4(0, 0, 0, 1)" for these attachments. The problem is that this is not what games expect. This commit reverts that change.
2020-01-24 05:15:50 +01:00
if (!header.ps.IsColorComponentOutputEnabled(rt, component)) {
continue;
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
}
vk_shader_decompiler: Disable default values on unwritten render targets Some games like The Legend of Zelda: Breath of the Wild assign render targets without writing them from the fragment shader. This generates Vulkan validation errors, so silence these I previously introduced a commit to set "vec4(0, 0, 0, 1)" for these attachments. The problem is that this is not what games expect. This commit reverts that change.
2020-01-24 05:15:50 +01:00
const Id pointer = AccessElement(t_out_float, frag_colors[rt], component);
OpStore(pointer, SafeGetRegister(current_reg));
++current_reg;
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
}
}
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.
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpStore(frag_depth, SafeGetRegister(current_reg + 1));
vk_shader_decompiler: Implement flow primitives
2019-03-14 06:48:16 +01:00
}
}
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Exit(Operation operation) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
PreExit();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
inside_branch = true;
if (conditional_branch_set) {
OpReturn();
vk_shader_compiler: Don't enclose branches with if(true) to avoid crashing AMD
2019-09-23 02:15:09 +02:00
} else {
const Id dummy = OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpBranch(dummy);
AddLabel(dummy);
OpReturn();
AddLabel();
vk_shader_compiler: Don't enclose branches with if(true) to avoid crashing AMD
2019-09-23 02:15:09 +02:00
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression Discard(Operation operation) {
inside_branch = true;
if (conditional_branch_set) {
OpKill();
vk_shader_compiler: Don't enclose branches with if(true) to avoid crashing AMD
2019-09-23 02:15:09 +02:00
} else {
const Id dummy = OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpBranch(dummy);
AddLabel(dummy);
OpKill();
AddLabel();
vk_shader_compiler: Don't enclose branches with if(true) to avoid crashing AMD
2019-09-23 02:15:09 +02:00
}
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression EmitVertex(Operation) {
OpEmitVertex();
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression EndPrimitive(Operation operation) {
OpEndPrimitive();
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression InvocationId(Operation) {
return {OpLoad(t_int, invocation_id), Type::Int};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression YNegate(Operation) {
vk_shader_decompiler: Reduce YNegate's severity
2019-12-10 03:51:43 +01:00
LOG_WARNING(Render_Vulkan, "(STUBBED)");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {Constant(t_float, 1.0f), Type::Float};
shader: Implement S2R Tid{XYZ} and CtaId{XYZ}
2019-05-03 08:00:51 +02:00
}
template <u32 element>
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression LocalInvocationId(Operation) {
const Id id = OpLoad(t_uint3, local_invocation_id);
return {OpCompositeExtract(t_uint, id, element), Type::Uint};
shader: Implement S2R Tid{XYZ} and CtaId{XYZ}
2019-05-03 08:00:51 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
template <u32 element>
Expression WorkGroupId(Operation operation) {
const Id id = OpLoad(t_uint3, workgroup_id);
return {OpCompositeExtract(t_uint, id, element), 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
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression BallotThread(Operation operation) {
const Id predicate = AsBool(Visit(operation[0]));
const Id ballot = OpSubgroupBallotKHR(t_uint4, predicate);
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
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (!device.IsWarpSizePotentiallyBiggerThanGuest()) {
// Guest-like devices can just return the first index.
return {OpCompositeExtract(t_uint, ballot, 0U), Type::Uint};
}
// The others will have to return what is local to the current thread.
// For instance a device with a warp size of 64 will return the upper uint when the current
// thread is 38.
const Id tid = OpLoad(t_uint, thread_id);
const Id thread_index = OpShiftRightLogical(t_uint, tid, Constant(t_uint, 5));
return {OpVectorExtractDynamic(t_uint, ballot, thread_index), 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
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
template <Id (Module::*func)(Id, Id)>
Expression Vote(Operation operation) {
// TODO(Rodrigo): Handle devices with different warp sizes
const Id predicate = AsBool(Visit(operation[0]));
return {(this->*func)(t_bool, predicate), 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
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression ThreadId(Operation) {
return {OpLoad(t_uint, thread_id), Type::Uint};
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
}
shader/other: Implement thread comparisons (NV_shader_thread_group) Hardware S2R special registers match gl_Thread*MaskNV. We can trivially implement these using Nvidia's extension on OpenGL or naively stubbing them with the ARB instructions to match. This might cause issues if the host device warp size doesn't match Nvidia's. That said, this is unlikely on proper shaders. Refer to the attached url for more documentation about these flags. https://www.khronos.org/registry/OpenGL/extensions/NV/NV_shader_thread_group.txt
2020-05-15 06:43:44 +02:00
template <std::size_t index>
Expression ThreadMask(Operation) {
// TODO(Rodrigo): Handle devices with different warp sizes
const Id mask = thread_masks[index];
return {OpLoad(t_uint, AccessElement(t_in_uint, mask, 0)), Type::Uint};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Expression ShuffleIndexed(Operation operation) {
const Id value = AsFloat(Visit(operation[0]));
const Id index = AsUint(Visit(operation[1]));
return {OpSubgroupReadInvocationKHR(t_float, value, index), Type::Float};
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
}
shader/other: Implement BAR.SYNC 0x0 Trivially implement this particular case of BAR. Unless games use OpenCL or CUDA barriers, we shouldn't hit any other case here.
2020-05-15 07:24:42 +02:00
Expression Barrier(Operation) {
if (!ir.IsDecompiled()) {
LOG_ERROR(Render_Vulkan, "OpBarrier used by shader is not decompiled");
return {};
}
const auto scope = spv::Scope::Workgroup;
const auto memory = spv::Scope::Workgroup;
const auto semantics =
spv::MemorySemanticsMask::WorkgroupMemory | spv::MemorySemanticsMask::AcquireRelease;
OpControlBarrier(Constant(t_uint, static_cast<u32>(scope)),
Constant(t_uint, static_cast<u32>(memory)),
Constant(t_uint, static_cast<u32>(semantics)));
return {};
}
shader/other: Implement MEMBAR.CTS This silences an assertion we were hitting and uses workgroup memory barriers when the game requests it.
2020-05-15 07:52:35 +02:00
template <spv::Scope scope>
Expression MemoryBarrier(Operation) {
shader: Implement MEMBAR.GL Implement using memoryBarrier in GLSL and OpMemoryBarrier on SPIR-V.
2019-12-10 01:46:12 +01:00
const auto semantics =
spv::MemorySemanticsMask::AcquireRelease | spv::MemorySemanticsMask::UniformMemory |
spv::MemorySemanticsMask::WorkgroupMemory |
spv::MemorySemanticsMask::AtomicCounterMemory | spv::MemorySemanticsMask::ImageMemory;
OpMemoryBarrier(Constant(t_uint, static_cast<u32>(scope)),
Constant(t_uint, static_cast<u32>(semantics)));
return {};
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id DeclareBuiltIn(spv::BuiltIn builtin, spv::StorageClass storage, Id type, std::string name) {
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id id = OpVariable(type, storage);
Decorate(id, spv::Decoration::BuiltIn, static_cast<u32>(builtin));
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
AddGlobalVariable(Name(id, std::move(name)));
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
interfaces.push_back(id);
return id;
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id DeclareInputBuiltIn(spv::BuiltIn builtin, Id type, std::string name) {
return DeclareBuiltIn(builtin, spv::StorageClass::Input, type, std::move(name));
}
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
template <typename... Args>
Id AccessElement(Id pointer_type, Id composite, Args... elements_) {
std::vector<Id> members;
auto elements = {elements_...};
for (const auto element : elements) {
members.push_back(Constant(t_uint, element));
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return OpAccessChain(pointer_type, composite, members);
vk_shader_decompiler: Implement non-OperationCode visits
2019-03-14 06:43:40 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id As(Expression expr, Type wanted_type) {
switch (wanted_type) {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Bool:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AsBool(expr);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Bool2:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AsBool2(expr);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Float:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AsFloat(expr);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Int:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AsInt(expr);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Uint:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AsUint(expr);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::HalfFloat:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return AsHalfFloat(expr);
default:
UNREACHABLE();
return expr.id;
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id AsBool(Expression expr) {
ASSERT(expr.type == Type::Bool);
return expr.id;
}
Id AsBool2(Expression expr) {
ASSERT(expr.type == Type::Bool2);
return expr.id;
}
Id AsFloat(Expression expr) {
switch (expr.type) {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Float:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return expr.id;
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Int:
case Type::Uint:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return OpBitcast(t_float, expr.id);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::HalfFloat:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (device.IsFloat16Supported()) {
return OpBitcast(t_float, expr.id);
}
return OpBitcast(t_float, OpPackHalf2x16(t_uint, expr.id));
default:
UNREACHABLE();
return expr.id;
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id AsInt(Expression expr) {
switch (expr.type) {
case Type::Int:
return expr.id;
case Type::Float:
case Type::Uint:
return OpBitcast(t_int, expr.id);
case Type::HalfFloat:
if (device.IsFloat16Supported()) {
return OpBitcast(t_int, expr.id);
}
return OpPackHalf2x16(t_int, expr.id);
default:
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
UNREACHABLE();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return expr.id;
}
}
Id AsUint(Expression expr) {
switch (expr.type) {
case Type::Uint:
return expr.id;
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::Float:
case Type::Int:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return OpBitcast(t_uint, expr.id);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
case Type::HalfFloat:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
if (device.IsFloat16Supported()) {
return OpBitcast(t_uint, expr.id);
}
return OpPackHalf2x16(t_uint, expr.id);
default:
UNREACHABLE();
return expr.id;
}
}
Id AsHalfFloat(Expression expr) {
switch (expr.type) {
case Type::HalfFloat:
return expr.id;
case Type::Float:
case Type::Int:
case Type::Uint:
if (device.IsFloat16Supported()) {
return OpBitcast(t_half, expr.id);
}
return OpUnpackHalf2x16(t_half, AsUint(expr));
default:
UNREACHABLE();
return expr.id;
}
}
Id GetHalfScalarFromFloat(Id value) {
if (device.IsFloat16Supported()) {
return OpFConvert(t_scalar_half, value);
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
}
return value;
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id GetFloatFromHalfScalar(Id value) {
if (device.IsFloat16Supported()) {
return OpFConvert(t_float, value);
}
return value;
}
AttributeType GetAttributeType(u32 location) const {
if (stage != ShaderType::Vertex) {
return {Type::Float, t_in_float, t_in_float4};
}
switch (specialization.attribute_types.at(location)) {
case Maxwell::VertexAttribute::Type::SignedNorm:
case Maxwell::VertexAttribute::Type::UnsignedNorm:
video_core: Implement more scaler attribute formats While changing this, fix assert in vk_shader_decompiler. We now know scaled formats are expected to be float in shaders attributes.
2020-02-23 21:45:58 +01:00
case Maxwell::VertexAttribute::Type::UnsignedScaled:
case Maxwell::VertexAttribute::Type::SignedScaled:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case Maxwell::VertexAttribute::Type::Float:
return {Type::Float, t_in_float, t_in_float4};
case Maxwell::VertexAttribute::Type::SignedInt:
return {Type::Int, t_in_int, t_in_int4};
case Maxwell::VertexAttribute::Type::UnsignedInt:
return {Type::Uint, t_in_uint, t_in_uint4};
default:
UNREACHABLE();
return {Type::Float, t_in_float, t_in_float4};
}
}
Id GetTypeDefinition(Type type) const {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
switch (type) {
case Type::Bool:
return t_bool;
case Type::Bool2:
return t_bool2;
case Type::Float:
return t_float;
case Type::Int:
return t_int;
case Type::Uint:
return t_uint;
case Type::HalfFloat:
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return t_half;
default:
UNREACHABLE();
return {};
}
}
std::array<Id, 4> GetTypeVectorDefinitionLut(Type type) const {
switch (type) {
case Type::Float:
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
return {t_float, t_float2, t_float3, t_float4};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case Type::Int:
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
return {t_int, t_int2, t_int3, t_int4};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
case Type::Uint:
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
return {t_uint, t_uint2, t_uint3, t_uint4};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
default:
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
UNIMPLEMENTED();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return {};
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01: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
std::tuple<Id, Id> CreateFlowStack() {
// TODO(Rodrigo): Figure out the actual depth of the flow stack, for now it seems unlikely
// that shaders will use 20 nested SSYs and PBKs.
constexpr u32 FLOW_STACK_SIZE = 20;
constexpr auto storage_class = spv::StorageClass::Function;
const Id flow_stack_type = TypeArray(t_uint, Constant(t_uint, FLOW_STACK_SIZE));
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id stack = OpVariable(TypePointer(storage_class, flow_stack_type), storage_class,
ConstantNull(flow_stack_type));
const Id top = OpVariable(t_func_uint, storage_class, Constant(t_uint, 0));
AddLocalVariable(stack);
AddLocalVariable(top);
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
return std::tie(stack, top);
}
std::pair<Id, Id> GetFlowStack(Operation operation) {
const auto stack_class = std::get<MetaStackClass>(operation.GetMeta());
switch (stack_class) {
case MetaStackClass::Ssy:
return {ssy_flow_stack, ssy_flow_stack_top};
case MetaStackClass::Pbk:
return {pbk_flow_stack, pbk_flow_stack_top};
}
UNREACHABLE();
return {};
}
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
Id GetGlobalMemoryPointer(const GmemNode& gmem) {
const Id real = AsUint(Visit(gmem.GetRealAddress()));
const Id base = AsUint(Visit(gmem.GetBaseAddress()));
const Id diff = OpISub(t_uint, real, base);
const Id offset = OpShiftRightLogical(t_uint, diff, Constant(t_uint, 2));
const Id buffer = global_buffers.at(gmem.GetDescriptor());
return OpAccessChain(t_gmem_uint, buffer, Constant(t_uint, 0), offset);
}
Id GetSharedMemoryPointer(const SmemNode& smem) {
ASSERT(stage == ShaderType::Compute);
Id address = AsUint(Visit(smem.GetAddress()));
address = OpShiftRightLogical(t_uint, address, Constant(t_uint, 2U));
return OpAccessChain(t_smem_uint, shared_memory, address);
}
shader/half_set_predicate: Fix HSETP2 implementation
2019-07-20 03:20:34 +02:00
static constexpr std::array operation_decompilers = {
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Assign,
&SPIRVDecompiler::Ternary<&Module::OpSelect, Type::Float, Type::Bool, Type::Float,
Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFAdd, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFMul, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFDiv, Type::Float>,
&SPIRVDecompiler::Ternary<&Module::OpFma, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpFNegate, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpFAbs, Type::Float>,
&SPIRVDecompiler::Ternary<&Module::OpFClamp, Type::Float>,
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
&SPIRVDecompiler::FCastHalf<0>,
&SPIRVDecompiler::FCastHalf<1>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Binary<&Module::OpFMin, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFMax, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpCos, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpSin, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpExp2, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpLog2, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpInverseSqrt, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpSqrt, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpRoundEven, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpFloor, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpCeil, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpTrunc, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpConvertSToF, Type::Float, Type::Int>,
&SPIRVDecompiler::Unary<&Module::OpConvertUToF, Type::Float, Type::Uint>,
shader_ir/warp: Implement FSWZADD
2019-11-03 03:44:46 +01:00
&SPIRVDecompiler::FSwizzleAdd,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Binary<&Module::OpIAdd, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpIMul, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpSDiv, Type::Int>,
&SPIRVDecompiler::Unary<&Module::OpSNegate, Type::Int>,
&SPIRVDecompiler::Unary<&Module::OpSAbs, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpSMin, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpSMax, Type::Int>,
&SPIRVDecompiler::Unary<&Module::OpConvertFToS, Type::Int, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpBitcast, Type::Int, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpShiftLeftLogical, Type::Int, Type::Int, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpShiftRightLogical, Type::Int, Type::Int, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpShiftRightArithmetic, Type::Int, Type::Int, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpBitwiseAnd, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpBitwiseOr, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpBitwiseXor, Type::Int>,
&SPIRVDecompiler::Unary<&Module::OpNot, Type::Int>,
&SPIRVDecompiler::Quaternary<&Module::OpBitFieldInsert, Type::Int>,
&SPIRVDecompiler::Ternary<&Module::OpBitFieldSExtract, Type::Int>,
&SPIRVDecompiler::Unary<&Module::OpBitCount, Type::Int>,
Shader_IR: Implement FLO instruction.
2019-11-12 15:07:22 +01:00
&SPIRVDecompiler::Unary<&Module::OpFindSMsb, Type::Int>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Binary<&Module::OpIAdd, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpIMul, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpUDiv, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpUMin, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpUMax, Type::Uint>,
&SPIRVDecompiler::Unary<&Module::OpConvertFToU, Type::Uint, Type::Float>,
&SPIRVDecompiler::Unary<&Module::OpBitcast, Type::Uint, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpShiftLeftLogical, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpShiftRightLogical, Type::Uint>,
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
&SPIRVDecompiler::Binary<&Module::OpShiftRightLogical, Type::Uint>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Binary<&Module::OpBitwiseAnd, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpBitwiseOr, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpBitwiseXor, Type::Uint>,
&SPIRVDecompiler::Unary<&Module::OpNot, Type::Uint>,
&SPIRVDecompiler::Quaternary<&Module::OpBitFieldInsert, Type::Uint>,
&SPIRVDecompiler::Ternary<&Module::OpBitFieldUExtract, Type::Uint>,
&SPIRVDecompiler::Unary<&Module::OpBitCount, Type::Uint>,
Shader_IR: Implement FLO instruction.
2019-11-12 15:07:22 +01:00
&SPIRVDecompiler::Unary<&Module::OpFindUMsb, Type::Uint>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Binary<&Module::OpFAdd, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFMul, Type::HalfFloat>,
&SPIRVDecompiler::Ternary<&Module::OpFma, Type::HalfFloat>,
&SPIRVDecompiler::Unary<&Module::OpFAbs, Type::HalfFloat>,
&SPIRVDecompiler::HNegate,
shader_ir/decode: Implement half float saturation
2019-04-09 23:41:41 +02:00
&SPIRVDecompiler::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
&SPIRVDecompiler::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
&SPIRVDecompiler::HUnpack,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::HMergeF32,
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
&SPIRVDecompiler::HMergeHN<0>,
&SPIRVDecompiler::HMergeHN<1>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::HPack2,
&SPIRVDecompiler::LogicalAssign,
&SPIRVDecompiler::Binary<&Module::OpLogicalAnd, Type::Bool>,
&SPIRVDecompiler::Binary<&Module::OpLogicalOr, Type::Bool>,
&SPIRVDecompiler::Binary<&Module::OpLogicalNotEqual, Type::Bool>,
&SPIRVDecompiler::Unary<&Module::OpLogicalNot, Type::Bool>,
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
&SPIRVDecompiler::Binary<&Module::OpVectorExtractDynamic, Type::Bool, Type::Bool2,
Type::Uint>,
&SPIRVDecompiler::Unary<&Module::OpAll, Type::Bool, Type::Bool2>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Binary<&Module::OpFOrdLessThan, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFOrdEqual, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFOrdLessThanEqual, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFOrdGreaterThan, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFOrdNotEqual, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFOrdGreaterThanEqual, Type::Bool, Type::Float>,
shader_ir: Separate float-point comparisons in ordered and unordered This allows us to use native SPIR-V instructions without having to manually check for NAN.
2020-05-09 09:55:15 +02:00
&SPIRVDecompiler::LogicalFOrdered,
&SPIRVDecompiler::LogicalFUnordered,
&SPIRVDecompiler::Binary<&Module::OpFUnordLessThan, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFUnordEqual, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFUnordLessThanEqual, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFUnordGreaterThan, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFUnordNotEqual, Type::Bool, Type::Float>,
&SPIRVDecompiler::Binary<&Module::OpFUnordGreaterThanEqual, Type::Bool, Type::Float>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Binary<&Module::OpSLessThan, Type::Bool, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpIEqual, Type::Bool, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpSLessThanEqual, Type::Bool, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpSGreaterThan, Type::Bool, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpINotEqual, Type::Bool, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpSGreaterThanEqual, Type::Bool, Type::Int>,
&SPIRVDecompiler::Binary<&Module::OpULessThan, Type::Bool, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpIEqual, Type::Bool, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpULessThanEqual, Type::Bool, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpUGreaterThan, Type::Bool, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpINotEqual, Type::Bool, Type::Uint>,
&SPIRVDecompiler::Binary<&Module::OpUGreaterThanEqual, Type::Bool, Type::Uint>,
shader/arithmetic_integer: Implement CC for IADD
2020-04-26 02:56:11 +02:00
&SPIRVDecompiler::LogicalAddCarry,
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
&SPIRVDecompiler::Binary<&Module::OpFOrdLessThan, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdEqual, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdLessThanEqual, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdGreaterThan, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdNotEqual, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdGreaterThanEqual, Type::Bool2, Type::HalfFloat>,
vk_shader_decompiler: Add missing operations
2019-04-16 02:32:24 +02:00
// TODO(Rodrigo): Should these use the OpFUnord* variants?
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
&SPIRVDecompiler::Binary<&Module::OpFOrdLessThan, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdEqual, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdLessThanEqual, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdGreaterThan, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdNotEqual, Type::Bool2, Type::HalfFloat>,
&SPIRVDecompiler::Binary<&Module::OpFOrdGreaterThanEqual, Type::Bool2, Type::HalfFloat>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Texture,
&SPIRVDecompiler::TextureLod,
&SPIRVDecompiler::TextureGather,
&SPIRVDecompiler::TextureQueryDimensions,
&SPIRVDecompiler::TextureQueryLod,
&SPIRVDecompiler::TexelFetch,
Shader_IR: Implement TXD instruction.
2019-11-12 18:43:08 +01:00
&SPIRVDecompiler::TextureGradient,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +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
&SPIRVDecompiler::ImageLoad,
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
&SPIRVDecompiler::ImageStore,
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
&SPIRVDecompiler::AtomicImage<&Module::OpAtomicIAdd>,
&SPIRVDecompiler::AtomicImage<&Module::OpAtomicAnd>,
&SPIRVDecompiler::AtomicImage<&Module::OpAtomicOr>,
&SPIRVDecompiler::AtomicImage<&Module::OpAtomicXor>,
&SPIRVDecompiler::AtomicImage<&Module::OpAtomicExchange>,
shader: Decode SUST and implement backing image functionality
2019-04-27 07:07:18 +02:00
shader/memory: Implement RED.E.ADD Implements a reduction operation. It's an atomic operation that doesn't return a value. This commit introduces another primitive because some shading languages might have a primitive for reduction operations.
2020-04-06 07:24:47 +02:00
&SPIRVDecompiler::Atomic<&Module::OpAtomicExchange>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicIAdd>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicUMin>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicUMax>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicAnd>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicOr>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicXor>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicExchange>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicIAdd>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicSMin>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicSMax>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicAnd>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicOr>,
&SPIRVDecompiler::Atomic<&Module::OpAtomicXor>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicIAdd>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicUMin>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicUMax>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicAnd>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicOr>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicXor>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicIAdd>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicSMin>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicSMax>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicAnd>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicOr>,
&SPIRVDecompiler::Reduce<&Module::OpAtomicXor>,
shader/memory: Implement ATOMS.ADD.U32
2020-01-16 08:00:52 +01:00
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::Branch,
shader_ir: Implement BRX & BRA.CC
2019-06-25 03:25:38 +02:00
&SPIRVDecompiler::BranchIndirect,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::PushFlowStack,
&SPIRVDecompiler::PopFlowStack,
&SPIRVDecompiler::Exit,
&SPIRVDecompiler::Discard,
&SPIRVDecompiler::EmitVertex,
&SPIRVDecompiler::EndPrimitive,
shader_ir/other: Implement S2R InvocationId
2019-10-30 22:17:27 +01:00
&SPIRVDecompiler::InvocationId,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
&SPIRVDecompiler::YNegate,
shader: Implement S2R Tid{XYZ} and CtaId{XYZ}
2019-05-03 08:00:51 +02:00
&SPIRVDecompiler::LocalInvocationId<0>,
&SPIRVDecompiler::LocalInvocationId<1>,
&SPIRVDecompiler::LocalInvocationId<2>,
&SPIRVDecompiler::WorkGroupId<0>,
&SPIRVDecompiler::WorkGroupId<1>,
&SPIRVDecompiler::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
&SPIRVDecompiler::BallotThread,
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
&SPIRVDecompiler::Vote<&Module::OpSubgroupAllKHR>,
&SPIRVDecompiler::Vote<&Module::OpSubgroupAnyKHR>,
&SPIRVDecompiler::Vote<&Module::OpSubgroupAllEqualKHR>,
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
&SPIRVDecompiler::ThreadId,
shader/other: Implement thread comparisons (NV_shader_thread_group) Hardware S2R special registers match gl_Thread*MaskNV. We can trivially implement these using Nvidia's extension on OpenGL or naively stubbing them with the ARB instructions to match. This might cause issues if the host device warp size doesn't match Nvidia's. That said, this is unlikely on proper shaders. Refer to the attached url for more documentation about these flags. https://www.khronos.org/registry/OpenGL/extensions/NV/NV_shader_thread_group.txt
2020-05-15 06:43:44 +02:00
&SPIRVDecompiler::ThreadMask<0>, // Eq
&SPIRVDecompiler::ThreadMask<1>, // Ge
&SPIRVDecompiler::ThreadMask<2>, // Gt
&SPIRVDecompiler::ThreadMask<3>, // Le
&SPIRVDecompiler::ThreadMask<4>, // Lt
shader_ir/warp: Implement SHFL
2019-08-27 03:09:12 +02:00
&SPIRVDecompiler::ShuffleIndexed,
shader: Implement MEMBAR.GL Implement using memoryBarrier in GLSL and OpMemoryBarrier on SPIR-V.
2019-12-10 01:46:12 +01:00
shader/other: Implement BAR.SYNC 0x0 Trivially implement this particular case of BAR. Unless games use OpenCL or CUDA barriers, we shouldn't hit any other case here.
2020-05-15 07:24:42 +02:00
&SPIRVDecompiler::Barrier,
shader/other: Implement MEMBAR.CTS This silences an assertion we were hitting and uses workgroup memory barriers when the game requests it.
2020-05-15 07:52:35 +02:00
&SPIRVDecompiler::MemoryBarrier<spv::Scope::Workgroup>,
&SPIRVDecompiler::MemoryBarrier<spv::Scope::Device>,
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +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));
vk_shader_decompiler: Implement OperationCode decompilation interface
2019-03-14 06:36:14 +01:00
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
const VKDevice& device;
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
const ShaderIR& ir;
video_core: Unify ProgramType and ShaderStage into ShaderType
2019-11-18 22:35:21 +01:00
const ShaderType stage;
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
const Tegra::Shader::Header header;
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
const Registry& registry;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Specialization& specialization;
vk/gl_shader_decompiler: Silence assertion on compute
2020-03-12 07:27:29 +01:00
std::unordered_map<u8, VaryingTFB> transform_feedback;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_void = Name(TypeVoid(), "void");
const Id t_bool = Name(TypeBool(), "bool");
const Id t_bool2 = Name(TypeVector(t_bool, 2), "bool2");
const Id t_int = Name(TypeInt(32, true), "int");
const Id t_int2 = Name(TypeVector(t_int, 2), "int2");
const Id t_int3 = Name(TypeVector(t_int, 3), "int3");
const Id t_int4 = Name(TypeVector(t_int, 4), "int4");
const Id t_uint = Name(TypeInt(32, false), "uint");
const Id t_uint2 = Name(TypeVector(t_uint, 2), "uint2");
const Id t_uint3 = Name(TypeVector(t_uint, 3), "uint3");
const Id t_uint4 = Name(TypeVector(t_uint, 4), "uint4");
const Id t_float = Name(TypeFloat(32), "float");
const Id t_float2 = Name(TypeVector(t_float, 2), "float2");
const Id t_float3 = Name(TypeVector(t_float, 3), "float3");
const Id t_float4 = Name(TypeVector(t_float, 4), "float4");
const Id t_prv_bool = Name(TypePointer(spv::StorageClass::Private, t_bool), "prv_bool");
const Id t_prv_float = Name(TypePointer(spv::StorageClass::Private, t_float), "prv_float");
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
const Id t_func_uint = Name(TypePointer(spv::StorageClass::Function, t_uint), "func_uint");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_in_bool = Name(TypePointer(spv::StorageClass::Input, t_bool), "in_bool");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id t_in_int = Name(TypePointer(spv::StorageClass::Input, t_int), "in_int");
const Id t_in_int4 = Name(TypePointer(spv::StorageClass::Input, t_int4), "in_int4");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_in_uint = Name(TypePointer(spv::StorageClass::Input, t_uint), "in_uint");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id t_in_uint3 = Name(TypePointer(spv::StorageClass::Input, t_uint3), "in_uint3");
const Id t_in_uint4 = Name(TypePointer(spv::StorageClass::Input, t_uint4), "in_uint4");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_in_float = Name(TypePointer(spv::StorageClass::Input, t_float), "in_float");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id t_in_float2 = Name(TypePointer(spv::StorageClass::Input, t_float2), "in_float2");
const Id t_in_float3 = Name(TypePointer(spv::StorageClass::Input, t_float3), "in_float3");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_in_float4 = Name(TypePointer(spv::StorageClass::Input, t_float4), "in_float4");
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id t_out_int = Name(TypePointer(spv::StorageClass::Output, t_int), "out_int");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_out_float = Name(TypePointer(spv::StorageClass::Output, t_float), "out_float");
const Id t_out_float4 = Name(TypePointer(spv::StorageClass::Output, t_float4), "out_float4");
const Id t_cbuf_float = TypePointer(spv::StorageClass::Uniform, t_float);
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
const Id t_cbuf_std140 = Decorate(
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Name(TypeArray(t_float4, Constant(t_uint, MaxConstBufferElements)), "CbufStd140Array"),
spv::Decoration::ArrayStride, 16U);
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
const Id t_cbuf_scalar = Decorate(
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Name(TypeArray(t_float, Constant(t_uint, MaxConstBufferFloats)), "CbufScalarArray"),
spv::Decoration::ArrayStride, 4U);
vk_shader_decompiler: Misc fixes Fix missing OpSelectionMerge instruction. This caused devices loses on most hardware, Intel didn't care. Fix [-1;1] -> [0;1] depth conversions. Conditionally use VK_EXT_scalar_block_layout. This allows us to use non-std140 layouts on UBOs. Update external Vulkan headers.
2019-05-26 06:43:07 +02:00
const Id t_cbuf_std140_struct = MemberDecorate(
Decorate(TypeStruct(t_cbuf_std140), spv::Decoration::Block), 0, spv::Decoration::Offset, 0);
const Id t_cbuf_scalar_struct = MemberDecorate(
Decorate(TypeStruct(t_cbuf_scalar), spv::Decoration::Block), 0, spv::Decoration::Offset, 0);
const Id t_cbuf_std140_ubo = TypePointer(spv::StorageClass::Uniform, t_cbuf_std140_struct);
const Id t_cbuf_scalar_ubo = TypePointer(spv::StorageClass::Uniform, t_cbuf_scalar_struct);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id t_smem_uint{};
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
const Id t_gmem_uint = TypePointer(spv::StorageClass::StorageBuffer, t_uint);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_gmem_array =
shader/memory: Implement ATOM.ADD ATOM operates atomically on global memory. For now only add ATOM.ADD since that's what was found in commercial games. This asserts for ATOM.ADD.S32 (handling the others as unimplemented), although ATOM.ADD.U32 shouldn't be any different. This change forces us to change the default type on SPIR-V storage buffers from float to uint. We could also alias the buffers, but it's simpler for now to just use uint. While we are at it, abstract the code to avoid repetition.
2020-01-26 01:03:02 +01:00
Name(Decorate(TypeRuntimeArray(t_uint), spv::Decoration::ArrayStride, 4U), "GmemArray");
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id t_gmem_struct = MemberDecorate(
Decorate(TypeStruct(t_gmem_array), spv::Decoration::Block), 0, spv::Decoration::Offset, 0);
const Id t_gmem_ssbo = TypePointer(spv::StorageClass::StorageBuffer, t_gmem_struct);
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
const Id t_image_uint = TypePointer(spv::StorageClass::Image, t_uint);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id v_float_zero = Constant(t_float, 0.0f);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
const Id v_float_one = Constant(t_float, 1.0f);
vk_shader_decompiler: Implement atomic image operations Implement atomic operations on images. On GLSL these are atomicImage* functions (e.g. atomicImageAdd).
2020-06-02 07:12:25 +02:00
const Id v_uint_zero = Constant(t_uint, 0);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
vk_shader_decompiler: Fix default varying regression
2020-03-12 06:35:31 +01:00
// Nvidia uses these defaults for varyings (e.g. position and generic attributes)
const Id v_varying_default =
ConstantComposite(t_float4, v_float_zero, v_float_zero, v_float_zero, v_float_one);
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
const Id v_true = ConstantTrue(t_bool);
const Id v_false = ConstantFalse(t_bool);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id t_scalar_half{};
Id t_half{};
Id out_vertex{};
Id in_vertex{};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
std::map<u32, Id> registers;
Shader_IR: Implement Injectable Custom Variables to the IR.
2020-01-07 19:53:46 +01:00
std::map<u32, Id> custom_variables;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
std::map<Tegra::Shader::Pred, Id> predicates;
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
std::map<u32, Id> flow_variables;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
Id local_memory{};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id shared_memory{};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
std::array<Id, INTERNAL_FLAGS_COUNT> internal_flags{};
std::map<Attribute::Index, Id> input_attributes;
vk_shader_decompiler: Add XFB decorations to generic varyings
2020-03-06 09:10:39 +01:00
std::unordered_map<u8, GenericVaryingDescription> output_attributes;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
std::map<u32, Id> constant_buffers;
std::map<GlobalMemoryBase, Id> global_buffers;
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
std::map<u32, TexelBuffer> uniform_texels;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
std::map<u32, SampledImage> sampled_images;
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
std::map<u32, TexelBuffer> storage_texels;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
std::map<u32, StorageImage> images;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
std::array<Id, Maxwell::NumRenderTargets> frag_colors{};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
Id instance_index{};
Id vertex_index{};
vk_shader_decompiler: Fix vertex id and instance id Vulkan's VertexIndex and InstanceIndex don't match with hardware. This is because Nvidia implements gl_VertexID and gl_InstanceID. The math that relates these is: gl_VertexIndex = gl_BaseVertex + gl_VertexID gl_InstanceIndex = gl_InstanceIndex + gl_InstanceID To emulate it using what Vulkan's SPIR-V offers (the *Index variants) this commit substracts gl_Base* from gl_*Index to obtain the OpenGL and hardware's equivalent.
2020-02-14 00:25:28 +01:00
Id base_instance{};
Id base_vertex{};
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
Id frag_depth{};
Id frag_coord{};
Id front_facing{};
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id point_coord{};
Id tess_level_outer{};
Id tess_level_inner{};
Id tess_coord{};
Id invocation_id{};
Id workgroup_id{};
Id local_invocation_id{};
Id thread_id{};
shader/other: Implement thread comparisons (NV_shader_thread_group) Hardware S2R special registers match gl_Thread*MaskNV. We can trivially implement these using Nvidia's extension on OpenGL or naively stubbing them with the ARB instructions to match. This might cause issues if the host device warp size doesn't match Nvidia's. That said, this is unlikely on proper shaders. Refer to the attached url for more documentation about these flags. https://www.khronos.org/registry/OpenGL/extensions/NV/NV_shader_thread_group.txt
2020-05-15 06:43:44 +02:00
std::array<Id, 5> thread_masks{}; // eq, ge, gt, le, lt
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
VertexIndices in_indices;
VertexIndices out_indices;
vk_shader_decompiler: Implement declarations
2019-03-14 06:23:37 +01:00
std::vector<Id> interfaces;
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
Id jmp_to{};
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
Id ssy_flow_stack_top{};
Id pbk_flow_stack_top{};
Id ssy_flow_stack{};
Id pbk_flow_stack{};
vk_shader_decompiler: Implement labels tree and flow
2019-03-14 06:27:06 +01:00
Id continue_label{};
std::map<u32, Id> labels;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
bool conditional_branch_set{};
bool inside_branch{};
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
};
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
class ExprDecompiler {
public:
Shader_Ir: Address Feedback and clang format.
2019-09-28 21:16:19 +02:00
explicit ExprDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {}
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id operator()(const ExprAnd& expr) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
const Id type_def = decomp.GetTypeDefinition(Type::Bool);
const Id op1 = Visit(expr.operand1);
const Id op2 = Visit(expr.operand2);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return decomp.OpLogicalAnd(type_def, op1, op2);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id operator()(const ExprOr& expr) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
const Id type_def = decomp.GetTypeDefinition(Type::Bool);
const Id op1 = Visit(expr.operand1);
const Id op2 = Visit(expr.operand2);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return decomp.OpLogicalOr(type_def, op1, op2);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id operator()(const ExprNot& expr) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
const Id type_def = decomp.GetTypeDefinition(Type::Bool);
const Id op1 = Visit(expr.operand1);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return decomp.OpLogicalNot(type_def, op1);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id operator()(const ExprPredicate& expr) {
vk_shader_decompiler: Clean code and be const correct.
2019-09-24 16:57:45 +02:00
const auto pred = static_cast<Tegra::Shader::Pred>(expr.predicate);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return decomp.OpLoad(decomp.t_bool, decomp.predicates.at(pred));
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id operator()(const ExprCondCode& expr) {
vk_shader_decompiler: Use Visit instead of reimplementing it ExprCondCode visit implements the generic Visit. Use this instead of that one. As an intended side effect this fixes unwritten memory usages in cases when a negation of a condition code is used.
2019-12-21 01:36:25 +01:00
return decomp.AsBool(decomp.Visit(decomp.ir.GetConditionCode(expr.cc)));
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id operator()(const ExprVar& expr) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
return decomp.OpLoad(decomp.t_bool, decomp.flow_variables.at(expr.var_index));
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id operator()(const ExprBoolean& expr) {
Shader_Ir: Address Feedback and clang format.
2019-09-28 21:16:19 +02:00
return expr.value ? decomp.v_true : decomp.v_false;
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
Shader_IR: Implement Fast BRX and allow multi-branches in the CFG.
2019-09-24 04:55:25 +02:00
Id operator()(const ExprGprEqual& expr) {
const Id target = decomp.Constant(decomp.t_uint, expr.value);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
Id gpr = decomp.OpLoad(decomp.t_float, decomp.registers.at(expr.gpr));
gpr = decomp.OpBitcast(decomp.t_uint, gpr);
vk_shader_decompiler: Fix full decompilation When full decompilation was enabled, labels were not being inserted and instructions were misused. Fix these bugs.
2019-12-19 05:46:20 +01:00
return decomp.OpIEqual(decomp.t_bool, gpr, target);
Shader_IR: Implement Fast BRX and allow multi-branches in the CFG.
2019-09-24 04:55:25 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
Id Visit(const Expr& node) {
Shader_Ir: Address Feedback and clang format.
2019-09-28 21:16:19 +02:00
return std::visit(*this, *node);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
private:
SPIRVDecompiler& decomp;
};
class ASTDecompiler {
public:
Shader_Ir: Address Feedback and clang format.
2019-09-28 21:16:19 +02:00
explicit ASTDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {}
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()(const ASTProgram& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ASTNode current = ast.nodes.GetFirst();
while (current) {
Visit(current);
current = current->GetNext();
}
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()(const ASTIfThen& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ExprDecompiler expr_parser{decomp};
const Id condition = expr_parser.Visit(ast.condition);
const Id then_label = decomp.OpLabel();
const Id endif_label = decomp.OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpSelectionMerge(endif_label, spv::SelectionControlMask::MaskNone);
decomp.OpBranchConditional(condition, then_label, endif_label);
decomp.AddLabel(then_label);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ASTNode current = ast.nodes.GetFirst();
while (current) {
Visit(current);
current = current->GetNext();
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpBranch(endif_label);
decomp.AddLabel(endif_label);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()([[maybe_unused]] const ASTIfElse& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
UNREACHABLE();
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()([[maybe_unused]] const ASTBlockEncoded& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
UNREACHABLE();
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()(const ASTBlockDecoded& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
decomp.VisitBasicBlock(ast.nodes);
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()(const ASTVarSet& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ExprDecompiler expr_parser{decomp};
const Id condition = expr_parser.Visit(ast.condition);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpStore(decomp.flow_variables.at(ast.index), condition);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()([[maybe_unused]] const ASTLabel& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
// Do nothing
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()([[maybe_unused]] const ASTGoto& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
UNREACHABLE();
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()(const ASTDoWhile& ast) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
const Id loop_label = decomp.OpLabel();
const Id endloop_label = decomp.OpLabel();
const Id loop_start_block = decomp.OpLabel();
vk_shader_decompiler: Fix full decompilation When full decompilation was enabled, labels were not being inserted and instructions were misused. Fix these bugs.
2019-12-19 05:46:20 +01:00
const Id loop_continue_block = decomp.OpLabel();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
current_loop_exit = endloop_label;
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpBranch(loop_label);
decomp.AddLabel(loop_label);
vk_shader_decompiler: Fix full decompilation When full decompilation was enabled, labels were not being inserted and instructions were misused. Fix these bugs.
2019-12-19 05:46:20 +01:00
decomp.OpLoopMerge(endloop_label, loop_continue_block, spv::LoopControlMask::MaskNone);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpBranch(loop_start_block);
decomp.AddLabel(loop_start_block);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ASTNode current = ast.nodes.GetFirst();
while (current) {
Visit(current);
current = current->GetNext();
}
vk_shader_decompiler: Fix full decompilation When full decompilation was enabled, labels were not being inserted and instructions were misused. Fix these bugs.
2019-12-19 05:46:20 +01:00
decomp.OpBranch(loop_continue_block);
decomp.AddLabel(loop_continue_block);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ExprDecompiler expr_parser{decomp};
const Id condition = expr_parser.Visit(ast.condition);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpBranchConditional(condition, loop_label, endloop_label);
decomp.AddLabel(endloop_label);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()(const ASTReturn& ast) {
vk_shader_decompiler: Clean code and be const correct.
2019-09-24 16:57:45 +02:00
if (!VideoCommon::Shader::ExprIsTrue(ast.condition)) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ExprDecompiler expr_parser{decomp};
const Id condition = expr_parser.Visit(ast.condition);
const Id then_label = decomp.OpLabel();
const Id endif_label = decomp.OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpSelectionMerge(endif_label, spv::SelectionControlMask::MaskNone);
decomp.OpBranchConditional(condition, then_label, endif_label);
decomp.AddLabel(then_label);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
if (ast.kills) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpKill();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
} else {
decomp.PreExit();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpReturn();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.AddLabel(endif_label);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
} else {
vk_shader_compiler: Correct SPIR-V AST Decompiling
2019-09-21 06:45:13 +02:00
const Id next_block = decomp.OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpBranch(next_block);
decomp.AddLabel(next_block);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
if (ast.kills) {
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpKill();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
} else {
decomp.PreExit();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpReturn();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.AddLabel(decomp.OpLabel());
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void operator()(const ASTBreak& ast) {
vk_shader_decompiler: Clean code and be const correct.
2019-09-24 16:57:45 +02:00
if (!VideoCommon::Shader::ExprIsTrue(ast.condition)) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ExprDecompiler expr_parser{decomp};
const Id condition = expr_parser.Visit(ast.condition);
const Id then_label = decomp.OpLabel();
const Id endif_label = decomp.OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpSelectionMerge(endif_label, spv::SelectionControlMask::MaskNone);
decomp.OpBranchConditional(condition, then_label, endif_label);
decomp.AddLabel(then_label);
decomp.OpBranch(current_loop_exit);
decomp.AddLabel(endif_label);
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
} else {
vk_shader_compiler: Correct SPIR-V AST Decompiling
2019-09-21 06:45:13 +02:00
const Id next_block = decomp.OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
decomp.OpBranch(next_block);
decomp.AddLabel(next_block);
decomp.OpBranch(current_loop_exit);
decomp.AddLabel(decomp.OpLabel());
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
void Visit(const ASTNode& node) {
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
std::visit(*this, *node->GetInnerData());
}
private:
SPIRVDecompiler& decomp;
Shader_Ir: Address Feedback and clang format.
2019-09-28 21:16:19 +02:00
Id current_loop_exit{};
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
};
void SPIRVDecompiler::DecompileAST() {
vk_shader_decompiler: Clean code and be const correct.
2019-09-24 16:57:45 +02:00
const u32 num_flow_variables = ir.GetASTNumVariables();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
for (u32 i = 0; i < num_flow_variables; i++) {
const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
Name(id, fmt::format("flow_var_{}", i));
flow_variables.emplace(i, AddGlobalVariable(id));
}
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
DefinePrologue();
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
const ASTNode program = ir.GetASTProgram();
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
ASTDecompiler decompiler{*this};
decompiler.Visit(program);
vk_shader_decompiler: Mark operator() function parameters as const references These parameters aren't actually modified in any way, so they can be made const references.
2019-10-18 01:36:55 +02:00
vk_shader_compiler: Correct SPIR-V AST Decompiling
2019-09-21 06:45:13 +02:00
const Id next_block = OpLabel();
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
OpBranch(next_block);
AddLabel(next_block);
}
} // Anonymous namespace
ShaderEntries GenerateShaderEntries(const VideoCommon::Shader::ShaderIR& ir) {
ShaderEntries entries;
for (const auto& cbuf : ir.GetConstantBuffers()) {
entries.const_buffers.emplace_back(cbuf.second, cbuf.first);
}
for (const auto& [base, usage] : ir.GetGlobalMemory()) {
entries.global_buffers.emplace_back(base.cbuf_index, base.cbuf_offset, usage.is_written);
}
for (const auto& sampler : ir.GetSamplers()) {
shader_ir: Turn classes into data structures
2020-04-16 06:34:45 +02:00
if (sampler.is_buffer) {
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
entries.uniform_texels.emplace_back(sampler);
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
} else {
entries.samplers.emplace_back(sampler);
}
}
for (const auto& image : ir.GetImages()) {
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
if (image.type == Tegra::Shader::ImageType::TextureBuffer) {
entries.storage_texels.emplace_back(image);
} else {
entries.images.emplace_back(image);
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
}
for (const auto& attribute : ir.GetInputAttributes()) {
if (IsGenericAttribute(attribute)) {
entries.attributes.insert(GetGenericAttributeLocation(attribute));
}
}
entries.clip_distances = ir.GetClipDistances();
entries.shader_length = ir.GetLength();
entries.uses_warps = ir.UsesWarps();
return entries;
vk_shader_compiler: Implement the decompiler in SPIR-V
2019-08-25 21:32:00 +02:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
std::vector<u32> Decompile(const VKDevice& device, const VideoCommon::Shader::ShaderIR& ir,
vk_shader_decompiler: Use registry for specialization
2020-03-03 01:36:25 +01:00
ShaderType stage, const VideoCommon::Shader::Registry& registry,
const Specialization& specialization) {
return SPIRVDecompiler(device, ir, stage, registry, specialization).Assemble();
vk_shader_decompiler: Declare and stub interface for a SPIR-V decompiler
2019-03-14 06:19:02 +01:00
}
vk_shader_decompiler: Misc changes Update Sirit and its usage in vk_shader_decompiler. Highlights: - Implement tessellation shaders - Implement geometry shaders - Implement some missing features - Use native half float instructions when available.
2019-12-10 03:44:29 +01:00
} // namespace Vulkan
Copy permalink