Vulkan: Implement Transform Feedback support via extension

Implemented transform feedback extension path. Where
VK_EXT_transform_feedback is supported, extension path will be taken
over an emulation path. Extension path has advantages in terms of
performance.

BUG=angleproject:3206
Test: dEQP-GLES3.functional.transform_feedback.*
      angle_end2end_tests --gtest_filter=TransformFeedbackTest*

Change-Id: Ia07c23afb289d9c67073469a97b714ec96f5265a
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1882767
Commit-Queue: Mohan Maiya <m.maiya@samsung.com>
Reviewed-by: Mohan Maiya <m.maiya@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Cody Northrop <cnorthrop@google.com>

Author: Hyunchang Kim

include/platform/FeaturesVk.h

@@ -134,6 +134,13 @@ struct FeaturesVk : FeatureSetBase
         "Emulate transform feedback as the VK_EXT_transform_feedback is not present.", &members,
         "http://anglebug.com/3205"};
 
+    // Where VK_EXT_transform_feedback is supported, it's preferred over an emulation path.
+    // http://anglebug.com/3206
+    Feature supportsTransformFeedbackExtension = {
+        "supports_transform_feedback_extension", FeatureCategory::VulkanFeatures,
+        "Transform feedback uses the VK_EXT_transform_feedback extension.", &members,
+        "http://anglebug.com/3206"};
+
     // VK_PRESENT_MODE_FIFO_KHR causes random timeouts on Linux Intel. http://anglebug.com/3153
     Feature disableFifoPresentMode = {
         "disable_fifo_present_mode", FeatureCategory::VulkanWorkarounds,

src/common/utilities.cpp

@@ -207,6 +207,54 @@ size_t VariableExternalSize(GLenum type)
     return VariableComponentSize(VariableComponentType(type)) * VariableComponentCount(type);
 }
 
+std::string GetGLSLTypeString(GLenum type)
+{
+    switch (type)
+    {
+        case GL_BOOL:
+            return "bool";
+        case GL_INT:
+            return "int";
+        case GL_UNSIGNED_INT:
+            return "uint";
+        case GL_FLOAT:
+            return "float";
+        case GL_BOOL_VEC2:
+            return "bvec2";
+        case GL_BOOL_VEC3:
+            return "bvec3";
+        case GL_BOOL_VEC4:
+            return "bvec4";
+        case GL_INT_VEC2:
+            return "ivec2";
+        case GL_INT_VEC3:
+            return "ivec3";
+        case GL_INT_VEC4:
+            return "ivec4";
+        case GL_FLOAT_VEC2:
+            return "vec2";
+        case GL_FLOAT_VEC3:
+            return "vec3";
+        case GL_FLOAT_VEC4:
+            return "vec4";
+        case GL_UNSIGNED_INT_VEC2:
+            return "uvec2";
+        case GL_UNSIGNED_INT_VEC3:
+            return "uvec3";
+        case GL_UNSIGNED_INT_VEC4:
+            return "uvec4";
+        case GL_FLOAT_MAT2:
+            return "mat2";
+        case GL_FLOAT_MAT3:
+            return "mat3";
+        case GL_FLOAT_MAT4:
+            return "mat4";
+        default:
+            UNREACHABLE();
+            return nullptr;
+    }
+}
+
 GLenum VariableBoolVectorType(GLenum type)
 {
     switch (type)

src/common/utilities.h

@@ -50,6 +50,7 @@ int MatrixRegisterCount(GLenum type, bool isRowMajorMatrix);
 int MatrixComponentCount(GLenum type, bool isRowMajorMatrix);
 int VariableSortOrder(GLenum type);
 GLenum VariableBoolVectorType(GLenum type);
+std::string GetGLSLTypeString(GLenum type);
 
 int AllocateFirstFreeBits(unsigned int *bits, unsigned int allocationSize, unsigned int bitsSize);
 

src/libANGLE/TransformFeedback.cpp

@@ -108,6 +108,11 @@ void TransformFeedback::onDestroy(const Context *context)
     {
         mState.mIndexedBuffers[i].set(context, nullptr, 0, 0);
     }
+
+    if (mImplementation)
+    {
+        mImplementation->onDestroy(context);
+    }
 }
 
 TransformFeedback::~TransformFeedback()

src/libANGLE/VaryingPacking.cpp

@@ -284,11 +284,16 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
 {
     std::set<std::string> uniqueFullNames;
     mPackedVaryings.clear();
+    mInputVaryings.clear();
 
     for (const auto &ref : mergedVaryings)
     {
         const sh::ShaderVariable *input  = ref.second.frontShader;
         const sh::ShaderVariable *output = ref.second.backShader;
+        if (input)
+        {
+            mInputVaryings.emplace_back(*input);
+        }
 
         // Only pack statically used varyings that have a matched input or output, plus special
         // builtins. Note that we pack all statically used user-defined varyings even if they are

src/libANGLE/VaryingPacking.h

@@ -182,6 +182,8 @@ class VaryingPacking final : angle::NonCopyable
         return mInactiveVaryingNames;
     }
 
+    const std::vector<sh::ShaderVariable> &getInputVaryings() const { return mInputVaryings; }
+
   private:
     bool packVarying(const PackedVarying &packedVarying);
     bool isFree(unsigned int registerRow,
@@ -194,6 +196,7 @@ class VaryingPacking final : angle::NonCopyable
 
     std::vector<Register> mRegisterMap;
     std::vector<PackedVaryingRegister> mRegisterList;
+    std::vector<sh::ShaderVariable> mInputVaryings;
     std::vector<PackedVarying> mPackedVaryings;
     std::vector<std::string> mInactiveVaryingNames;
 

src/libANGLE/renderer/TransformFeedbackImpl.h

@@ -20,6 +20,7 @@ class TransformFeedbackImpl : angle::NonCopyable
   public:
     TransformFeedbackImpl(const gl::TransformFeedbackState &state) : mState(state) {}
     virtual ~TransformFeedbackImpl() {}
+    virtual void onDestroy(const gl::Context *context) {}
 
     virtual angle::Result begin(const gl::Context *context, gl::PrimitiveMode primitiveMode) = 0;
     virtual angle::Result end(const gl::Context *context)                                    = 0;