video: Import new shader recompiler + display a triangle (#142)

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -0,0 +1,169 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <sirit/sirit.h>
+
+#include "shader_recompiler/backend/bindings.h"
+#include "shader_recompiler/ir/program.h"
+#include "shader_recompiler/profile.h"
+#include "shader_recompiler/runtime_info.h"
+
+namespace Shader::Backend::SPIRV {
+
+using Sirit::Id;
+
+struct VectorIds {
+    [[nodiscard]] Id& operator[](u32 index) {
+        return ids[index - 1];
+    }
+
+    [[nodiscard]] const Id& operator[](u32 index) const {
+        return ids[index - 1];
+    }
+
+    std::array<Id, 4> ids;
+};
+
+class EmitContext final : public Sirit::Module {
+public:
+    explicit EmitContext(const Profile& profile, IR::Program& program, Bindings& binding);
+    ~EmitContext();
+
+    Id Def(const IR::Value& value);
+
+    [[nodiscard]] Id DefineInput(Id type, u32 location) {
+        const Id input_id{DefineVar(type, spv::StorageClass::Input)};
+        Decorate(input_id, spv::Decoration::Location, location);
+        return input_id;
+    }
+
+    [[nodiscard]] Id DefineOutput(Id type, std::optional<u32> location = std::nullopt) {
+        const Id output_id{DefineVar(type, spv::StorageClass::Output)};
+        if (location) {
+            Decorate(output_id, spv::Decoration::Location, *location);
+        }
+        return output_id;
+    }
+
+    [[nodiscard]] Id DefineUniformConst(Id type, u32 set, u32 binding, bool readonly = false) {
+        const Id uniform_id{DefineVar(type, spv::StorageClass::UniformConstant)};
+        Decorate(uniform_id, spv::Decoration::DescriptorSet, set);
+        Decorate(uniform_id, spv::Decoration::Binding, binding);
+        if (readonly) {
+            Decorate(uniform_id, spv::Decoration::NonWritable);
+        }
+        return uniform_id;
+    }
+
+    template <bool global = true>
+    [[nodiscard]] Id DefineVar(Id type, spv::StorageClass storage_class) {
+        const Id pointer_type_id{TypePointer(storage_class, type)};
+        return global ? AddGlobalVariable(pointer_type_id, storage_class)
+                      : AddLocalVariable(pointer_type_id, storage_class);
+    }
+
+    [[nodiscard]] Id DefineVariable(Id type, std::optional<spv::BuiltIn> builtin,
+                                    spv::StorageClass storage_class) {
+        const Id id{DefineVar(type, storage_class)};
+        if (builtin) {
+            Decorate(id, spv::Decoration::BuiltIn, *builtin);
+        }
+        interfaces.push_back(id);
+        return id;
+    }
+
+    [[nodiscard]] Id ConstU32(u32 value) {
+        return Constant(U32[1], value);
+    }
+
+    template <typename... Args>
+    [[nodiscard]] Id ConstU32(Args&&... values) {
+        constexpr u32 size = static_cast<u32>(sizeof...(values));
+        static_assert(size >= 2);
+        const std::array constituents{Constant(U32[1], values)...};
+        const Id type = size <= 4 ? U32[size] : TypeArray(U32[1], ConstU32(size));
+        return ConstantComposite(type, constituents);
+    }
+
+    [[nodiscard]] Id ConstS32(s32 value) {
+        return Constant(S32[1], value);
+    }
+
+    template <typename... Args>
+    [[nodiscard]] Id ConstS32(Args&&... values) {
+        constexpr u32 size = static_cast<u32>(sizeof...(values));
+        static_assert(size >= 2);
+        const std::array constituents{Constant(S32[1], values)...};
+        const Id type = size <= 4 ? S32[size] : TypeArray(S32[1], ConstU32(size));
+        return ConstantComposite(type, constituents);
+    }
+
+    [[nodiscard]] Id ConstF32(f32 value) {
+        return Constant(F32[1], value);
+    }
+
+    template <typename... Args>
+    [[nodiscard]] Id ConstF32(Args... values) {
+        constexpr u32 size = static_cast<u32>(sizeof...(values));
+        static_assert(size >= 2);
+        const std::array constituents{Constant(F32[1], values)...};
+        const Id type = size <= 4 ? F32[size] : TypeArray(F32[1], ConstU32(size));
+        return ConstantComposite(type, constituents);
+    }
+
+    const Profile& profile;
+    Stage stage{};
+
+    Id void_id{};
+    Id U8{};
+    Id S8{};
+    Id U16{};
+    Id S16{};
+    Id U64{};
+    VectorIds F16{};
+    VectorIds F32{};
+    VectorIds F64{};
+    VectorIds S32{};
+    VectorIds U32{};
+    VectorIds U1{};
+
+    Id true_value{};
+    Id false_value{};
+    Id u32_zero_value{};
+    Id f32_zero_value{};
+
+    Id output_u32{};
+    Id output_f32{};
+
+    boost::container::small_vector<Id, 16> interfaces;
+
+    Id output_position{};
+    Id vertex_index{};
+    Id base_vertex{};
+    std::array<Id, 8> frag_color{};
+
+    struct InputParamInfo {
+        Id id;
+        Id pointer_type;
+        Id component_type;
+    };
+    std::array<InputParamInfo, 32> input_params{};
+
+    struct ParamElementInfo {
+        Id id{};
+        u32 first_element{};
+        u32 num_components{};
+    };
+    std::array<std::array<ParamElementInfo, 4>, 32> output_params{};
+
+private:
+    void DefineArithmeticTypes();
+    void DefineInterfaces(const IR::Program& program);
+    void DefineInputs(const IR::Program& program);
+    void DefineOutputs(const IR::Program& program);
+};
+
+} // namespace Shader::Backend::SPIRV