video_core: Bringup some basic functionality (#145)

* video_core: Remove hack in rasterizer

* The hack was to skip the first draw as the display buffer had not been created yet and the texture cache couldn't create one itself. With this patch it now can, using the color buffer parameters from registers

* shader_recompiler: Implement attribute loads/stores

* video_core: Add basic vertex, index buffer handling and pipeline caching

* externals: Make xxhash lowercase

src/shader_recompiler/runtime_info.h

@@ -3,39 +3,16 @@
 
 #pragma once
 
-#include <array>
-#include <boost/container/small_vector.hpp>
-#include "shader_recompiler/ir/type.h"
+#include <span>
+#include <boost/container/static_vector.hpp>
+#include "common/assert.h"
+#include "common/types.h"
+#include "shader_recompiler/ir/attribute.h"
+#include "video_core/amdgpu/pixel_format.h"
 
 namespace Shader {
 
-enum class AttributeType : u8 {
-    Float,
-    SignedInt,
-    UnsignedInt,
-    SignedScaled,
-    UnsignedScaled,
-    Disabled,
-};
-
-enum class InputTopology {
-    Points,
-    Lines,
-    LinesAdjacency,
-    Triangles,
-    TrianglesAdjacency,
-};
-
-enum class CompareFunction {
-    Never,
-    Less,
-    Equal,
-    LessThanEqual,
-    Greater,
-    NotEqual,
-    GreaterThanEqual,
-    Always,
-};
+static constexpr size_t NumUserDataRegs = 16;
 
 enum class Stage : u32 {
     Vertex,
@@ -62,78 +39,64 @@ enum class TextureType : u32 {
 };
 constexpr u32 NUM_TEXTURE_TYPES = 7;
 
-enum class Interpolation {
-    Smooth,
-    Flat,
-    NoPerspective,
-};
-
-struct ConstantBufferDescriptor {
-    u32 index;
-    u32 count;
-
-    auto operator<=>(const ConstantBufferDescriptor&) const = default;
-};
-
-struct TextureDescriptor {
-    TextureType type;
-    bool is_eud;
-    bool is_depth;
-    bool is_multisample;
-    bool is_storage;
-    u32 count;
-    u32 eud_offset_dwords;
-    u32 ud_index_dwords;
-
-    auto operator<=>(const TextureDescriptor&) const = default;
-};
-using TextureDescriptors = boost::container::small_vector<TextureDescriptor, 12>;
-
 struct Info {
-    bool uses_workgroup_id{};
-    bool uses_local_invocation_id{};
-    bool uses_invocation_id{};
-    bool uses_invocation_info{};
-    bool uses_sample_id{};
+    struct VsInput {
+        AmdGpu::NumberFormat fmt;
+        u16 binding;
+        u16 num_components;
+        u8 sgpr_base;
+        u8 dword_offset;
+    };
+    boost::container::static_vector<VsInput, 32> vs_inputs{};
 
-    std::array<Interpolation, 32> interpolation{};
-    // VaryingState loads;
-    // VaryingState stores;
-    // VaryingState passthrough;
+    struct PsInput {
+        u32 param_index;
+        u32 semantic;
+        bool is_default;
+        bool is_flat;
+        u32 default_value;
+    };
+    boost::container::static_vector<PsInput, 32> ps_inputs{};
 
-    std::array<bool, 8> stores_frag_color{};
-    bool stores_sample_mask{};
-    bool stores_frag_depth{};
+    struct AttributeFlags {
+        bool Get(IR::Attribute attrib, u32 comp = 0) const {
+            return flags[Index(attrib)] & (1 << comp);
+        }
 
-    bool uses_fp16{};
-    bool uses_fp64{};
-    bool uses_fp16_denorms_flush{};
-    bool uses_fp16_denorms_preserve{};
-    bool uses_fp32_denorms_flush{};
-    bool uses_fp32_denorms_preserve{};
-    bool uses_int8{};
-    bool uses_int16{};
-    bool uses_int64{};
-    bool uses_image_1d{};
-    bool uses_sampled_1d{};
-    bool uses_subgroup_vote{};
-    bool uses_subgroup_mask{};
-    bool uses_derivatives{};
+        bool GetAny(IR::Attribute attrib) const {
+            return flags[Index(attrib)];
+        }
 
-    IR::Type used_constant_buffer_types{};
-    IR::Type used_storage_buffer_types{};
-    IR::Type used_indirect_cbuf_types{};
+        void Set(IR::Attribute attrib, u32 comp = 0) {
+            flags[Index(attrib)] |= (1 << comp);
+        }
 
-    // std::array<u32, MAX_CBUFS> constant_buffer_used_sizes{};
-    u32 used_clip_distances{};
+        u32 NumComponents(IR::Attribute attrib) const {
+            const u8 mask = flags[Index(attrib)];
+            ASSERT(mask != 0b1011 || mask != 0b1101);
+            return std::popcount(mask);
+        }
 
-    // boost::container::static_vector<ConstantBufferDescriptor, MAX_CBUFS>
-    //     constant_buffer_descriptors;
-    // boost::container::static_vector<StorageBufferDescriptor, MAX_SSBOS>
-    // storage_buffers_descriptors; TextureBufferDescriptors texture_buffer_descriptors;
-    // ImageBufferDescriptors image_buffer_descriptors;
-    // TextureDescriptors texture_descriptors;
-    // ImageDescriptors image_descriptors;
+        static size_t Index(IR::Attribute attrib) {
+            return static_cast<size_t>(attrib);
+        }
+
+        std::array<u8, IR::NumAttributes> flags;
+    };
+    AttributeFlags loads{};
+    AttributeFlags stores{};
+
+    std::span<const u32> user_data;
+    Stage stage;
+
+    template <typename T>
+    T ReadUd(u32 ptr_index, u32 dword_offset) const noexcept {
+        T data;
+        u32* base;
+        std::memcpy(&base, &user_data[ptr_index], sizeof(base));
+        std::memcpy(&data, base + dword_offset, sizeof(T));
+        return data;
+    }
 };
 
 } // namespace Shader