Add support for 2x2 matrices

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1755483002

Review URL: https://codereview.chromium.org/1755483002

3 files changed, 71 insertions, 81 deletions

diff --git a/src/gpu/vk/GrVkProgramDataManager.cpp b/src/gpu/vk/GrVkProgramDataManager.cpp
index 732e937ef5..f189097b97 100644
--- a/src/gpu/vk/GrVkProgramDataManager.cpp
+++ b/src/gpu/vk/GrVkProgramDataManager.cpp
@@ -209,81 +209,37 @@ void GrVkProgramDataManager::set4fv(UniformHandle u,
     memcpy(buffer, v, arrayCount * 4 * sizeof(float));
 }
 
-void GrVkProgramDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const {
-    const Uniform& uni = fUniforms[u.toIndex()];
-    SkASSERT(uni.fType == kMat33f_GrSLType);
-    SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
-    SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber);
-    void* buffer;
-    if (GrVkUniformHandler::kVertexBinding == uni.fBinding) {
-        buffer = fVertexUniformData.get();
-    } else {
-        SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
-        buffer = fFragmentUniformData.get();
-    }
-
-    SkASSERT(sizeof(float) == 4);
-    buffer = static_cast<char*>(buffer) + uni.fOffset;
-    memcpy(buffer, &matrix[0], 3 * sizeof(float));
-    buffer = static_cast<char*>(buffer) + 4*sizeof(float);
-    memcpy(buffer, &matrix[3], 3 * sizeof(float));
-    buffer = static_cast<char*>(buffer) + 4*sizeof(float);
-    memcpy(buffer, &matrix[6], 3 * sizeof(float));
+void GrVkProgramDataManager::setMatrix2f(UniformHandle u, const float matrix[]) const {
+    this->setMatrices<2>(u, 1, matrix);
 }
 
-void GrVkProgramDataManager::setMatrix3fv(UniformHandle u,
-                                          int arrayCount,
-                                          const float matrices[]) const {
-    const Uniform& uni = fUniforms[u.toIndex()];
-    SkASSERT(uni.fType == kMat33f_GrSLType);
-    SkASSERT(arrayCount > 0);
-    SkASSERT(arrayCount <= uni.fArrayCount ||
-             (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount));
-    SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber);
+void GrVkProgramDataManager::setMatrix2fv(UniformHandle u, int arrayCount, const float m[]) const {
+    this->setMatrices<2>(u, arrayCount, m);
+}
 
-    void* buffer;
-    if (GrVkUniformHandler::kVertexBinding == uni.fBinding) {
-        buffer = fVertexUniformData.get();
-    } else {
-        SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
-        buffer = fFragmentUniformData.get();
-    }
-    SkASSERT(sizeof(float) == 4);
-    buffer = static_cast<char*>(buffer)+uni.fOffset;
-    for (int i = 0; i < arrayCount; ++i) {
-        const float* matrix = &matrices[9 * i];
-        memcpy(buffer, &matrix[0], 3 * sizeof(float));
-        buffer = static_cast<char*>(buffer) + 4*sizeof(float);
-        memcpy(buffer, &matrix[3], 3 * sizeof(float));
-        buffer = static_cast<char*>(buffer) + 4*sizeof(float);
-        memcpy(buffer, &matrix[6], 3 * sizeof(float));
-        buffer = static_cast<char*>(buffer) + 4*sizeof(float);
-    }
+void GrVkProgramDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const {
+    this->setMatrices<3>(u, 1, matrix);
 }
 
+void GrVkProgramDataManager::setMatrix3fv(UniformHandle u, int arrayCount, const float m[]) const {
+    this->setMatrices<3>(u, arrayCount, m);
+}
 
 void GrVkProgramDataManager::setMatrix4f(UniformHandle u, const float matrix[]) const {
-    const Uniform& uni = fUniforms[u.toIndex()];
-    SkASSERT(uni.fType == kMat44f_GrSLType);
-    SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
-    SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber);
-    void* buffer;
-    if (GrVkUniformHandler::kVertexBinding == uni.fBinding) {
-        buffer = fVertexUniformData.get();
-    } else {
-        SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
-        buffer = fFragmentUniformData.get();
-    }
-    buffer = static_cast<char*>(buffer) + uni.fOffset;
-    SkASSERT(sizeof(float) == 4);
-    memcpy(buffer, matrix, 16 * sizeof(float));
+    this->setMatrices<4>(u, 1, matrix);
 }
 
-void GrVkProgramDataManager::setMatrix4fv(UniformHandle u,
-                                          int arrayCount,
-                                          const float matrices[]) const {
+void GrVkProgramDataManager::setMatrix4fv(UniformHandle u, int arrayCount, const float m[]) const {
+    this->setMatrices<4>(u, arrayCount, m);
+}
+
+template<int N> struct set_uniform_matrix;
+
+template<int N> inline void GrVkProgramDataManager::setMatrices(UniformHandle u,
+                                                                   int arrayCount,
+                                                                   const float matrices[]) const {
     const Uniform& uni = fUniforms[u.toIndex()];
-    SkASSERT(uni.fType == kMat44f_GrSLType);
+    SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2));
     SkASSERT(arrayCount > 0);
     SkASSERT(arrayCount <= uni.fArrayCount ||
              (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount));
@@ -296,11 +252,34 @@ void GrVkProgramDataManager::setMatrix4fv(UniformHandle u,
         SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
         buffer = fFragmentUniformData.get();
     }
-    buffer = static_cast<char*>(buffer) + uni.fOffset;
-    SkASSERT(sizeof(float) == 4);
-    memcpy(buffer, matrices, arrayCount * 16 * sizeof(float));
+
+    set_uniform_matrix<N>::set(buffer, uni.fOffset, arrayCount, matrices);
 }
 
+template<int N> struct set_uniform_matrix {
+    inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
+        GR_STATIC_ASSERT(sizeof(float) == 4);
+        buffer = static_cast<char*>(buffer) + uniformOffset;
+        for (int i = 0; i < count; ++i) {
+            const float* matrix = &matrices[N * N * i];
+            memcpy(buffer, &matrix[0], N * sizeof(float));
+            buffer = static_cast<char*>(buffer) + 4*sizeof(float);
+            memcpy(buffer, &matrix[3], N * sizeof(float));
+            buffer = static_cast<char*>(buffer) + 4*sizeof(float);
+            memcpy(buffer, &matrix[6], N * sizeof(float));
+            buffer = static_cast<char*>(buffer) + 4*sizeof(float);
+        }
+    }
+};
+
+template<> struct set_uniform_matrix<4> {
+    inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
+        GR_STATIC_ASSERT(sizeof(float) == 4);
+        buffer = static_cast<char*>(buffer) + uniformOffset;
+        memcpy(buffer, matrices, count * 16 * sizeof(float));
+    }
+};
+
 void GrVkProgramDataManager::uploadUniformBuffers(const GrVkGpu* gpu,
                                                   GrVkUniformBuffer* vertexBuffer,
                                                   GrVkUniformBuffer* fragmentBuffer) const {
diff --git a/src/gpu/vk/GrVkProgramDataManager.h b/src/gpu/vk/GrVkProgramDataManager.h
index 800625902a..3baef0a742 100644
--- a/src/gpu/vk/GrVkProgramDataManager.h
+++ b/src/gpu/vk/GrVkProgramDataManager.h
@@ -33,8 +33,10 @@ public:
     void set4fv(UniformHandle, int arrayCount, const float v[]) const override;
     // matrices are column-major, the first two upload a single matrix, the latter two upload
     // arrayCount matrices into a uniform array.
+    void setMatrix2f(UniformHandle, const float matrix[]) const override;
     void setMatrix3f(UniformHandle, const float matrix[]) const override;
     void setMatrix4f(UniformHandle, const float matrix[]) const override;
+    void setMatrix2fv(UniformHandle, int arrayCount, const float matrices[]) const override;
     void setMatrix3fv(UniformHandle, int arrayCount, const float matrices[]) const override;
     void setMatrix4fv(UniformHandle, int arrayCount, const float matrices[]) const override;
 
@@ -58,6 +60,9 @@ private:
         );
     };
 
+    template<int N> inline void setMatrices(UniformHandle, int arrayCount,
+                                            const float matrices[]) const;
+
     uint32_t fVertexUniformSize;
     uint32_t fFragmentUniformSize;
 
diff --git a/src/gpu/vk/GrVkUniformHandler.cpp b/src/gpu/vk/GrVkUniformHandler.cpp
index 55b41abf49..ac6da190d7 100644
--- a/src/gpu/vk/GrVkUniformHandler.cpp
+++ b/src/gpu/vk/GrVkUniformHandler.cpp
@@ -22,6 +22,7 @@ uint32_t grsltype_to_alignment_mask(GrSLType type) {
         0x7, // kVec2f_GrSLType
         0xF, // kVec3f_GrSLType
         0xF, // kVec4f_GrSLType
+        0x7, // kMat22f_GrSLType
         0xF, // kMat33f_GrSLType
         0xF, // kMat44f_GrSLType
         0x0, // Sampler2D_GrSLType, should never return this
@@ -32,10 +33,11 @@ uint32_t grsltype_to_alignment_mask(GrSLType type) {
     GR_STATIC_ASSERT(2 == kVec2f_GrSLType);
     GR_STATIC_ASSERT(3 == kVec3f_GrSLType);
     GR_STATIC_ASSERT(4 == kVec4f_GrSLType);
-    GR_STATIC_ASSERT(5 == kMat33f_GrSLType);
-    GR_STATIC_ASSERT(6 == kMat44f_GrSLType);
-    GR_STATIC_ASSERT(7 == kSampler2D_GrSLType);
-    GR_STATIC_ASSERT(8 == kSamplerExternal_GrSLType);
+    GR_STATIC_ASSERT(5 == kMat22f_GrSLType);
+    GR_STATIC_ASSERT(6 == kMat33f_GrSLType);
+    GR_STATIC_ASSERT(7 == kMat44f_GrSLType);
+    GR_STATIC_ASSERT(8 == kSampler2D_GrSLType);
+    GR_STATIC_ASSERT(9 == kSamplerExternal_GrSLType);
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(kAlignments) == kGrSLTypeCount);
     return kAlignments[type];
 }
@@ -44,12 +46,14 @@ uint32_t grsltype_to_alignment_mask(GrSLType type) {
     For non floating point type returns 0 */
 static inline uint32_t grsltype_to_vk_size(GrSLType type) {
     SkASSERT(GrSLTypeIsFloatType(type));
+    SkASSERT(kMat22f_GrSLType != type); // TODO: handle mat2 differences between std140 and std430.
     static const uint32_t kSizes[] = {
         0,                        // kVoid_GrSLType
         sizeof(float),            // kFloat_GrSLType
         2 * sizeof(float),        // kVec2f_GrSLType
         3 * sizeof(float),        // kVec3f_GrSLType
         4 * sizeof(float),        // kVec4f_GrSLType
+        8 * sizeof(float),        // kMat22f_GrSLType. TODO: this will be 4 * szof(float) on std430.
         12 * sizeof(float),       // kMat33f_GrSLType
         16 * sizeof(float),       // kMat44f_GrSLType
         0,                        // kSampler2D_GrSLType
@@ -66,15 +70,16 @@ static inline uint32_t grsltype_to_vk_size(GrSLType type) {
     GR_STATIC_ASSERT(2 == kVec2f_GrSLType);
     GR_STATIC_ASSERT(3 == kVec3f_GrSLType);
     GR_STATIC_ASSERT(4 == kVec4f_GrSLType);
-    GR_STATIC_ASSERT(5 == kMat33f_GrSLType);
-    GR_STATIC_ASSERT(6 == kMat44f_GrSLType);
-    GR_STATIC_ASSERT(7 == kSampler2D_GrSLType);
-    GR_STATIC_ASSERT(8 == kSamplerExternal_GrSLType);
-    GR_STATIC_ASSERT(9 == kSampler2DRect_GrSLType);
-    GR_STATIC_ASSERT(10 == kBool_GrSLType);
-    GR_STATIC_ASSERT(11 == kInt_GrSLType);
-    GR_STATIC_ASSERT(12 == kUint_GrSLType);
-    GR_STATIC_ASSERT(13 == kGrSLTypeCount);
+    GR_STATIC_ASSERT(5 == kMat22f_GrSLType);
+    GR_STATIC_ASSERT(6 == kMat33f_GrSLType);
+    GR_STATIC_ASSERT(7 == kMat44f_GrSLType);
+    GR_STATIC_ASSERT(8 == kSampler2D_GrSLType);
+    GR_STATIC_ASSERT(9 == kSamplerExternal_GrSLType);
+    GR_STATIC_ASSERT(10 == kSampler2DRect_GrSLType);
+    GR_STATIC_ASSERT(11 == kBool_GrSLType);
+    GR_STATIC_ASSERT(12 == kInt_GrSLType);
+    GR_STATIC_ASSERT(13 == kUint_GrSLType);
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(kSizes) == kGrSLTypeCount);
 }
 
 
@@ -87,6 +92,7 @@ void get_ubo_aligned_offset(uint32_t* uniformOffset,
                             int arrayCount) {
     uint32_t alignmentMask = grsltype_to_alignment_mask(type);
     // We want to use the std140 layout here, so we must make arrays align to 16 bytes.
+    SkASSERT(type != kMat22f_GrSLType); // TODO: support mat2.
     if (arrayCount) {
         alignmentMask = 0xF;
     }