text: /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
  #include "GrVkPipelineStateDataManager.h"
  
  #include "GrVkGpu.h"
  #include "GrVkUniformBuffer.h"
  
  GrVkPipelineStateDataManager::GrVkPipelineStateDataManager(const UniformInfoArray& uniforms,
                                                             uint32_t geometryUniformSize,
                                                             uint32_t fragmentUniformSize)
      : fGeometryUniformSize(geometryUniformSize)
      , fFragmentUniformSize(fragmentUniformSize)
      , fGeometryUniformsDirty(false)
      , fFragmentUniformsDirty(false) {
      fGeometryUniformData.reset(geometryUniformSize);
      fFragmentUniformData.reset(fragmentUniformSize);
      int count = uniforms.count();
      fUniforms.push_back_n(count);
      // We must add uniforms in same order is the UniformInfoArray so that UniformHandles already
      // owned by other objects will still match up here.
      for (int i = 0; i < count; i++) {
          Uniform& uniform = fUniforms[i];
          const GrVkUniformHandler::UniformInfo uniformInfo = uniforms[i];
          SkASSERT(GrShaderVar::kNonArray == uniformInfo.fVariable.getArrayCount() ||
                   uniformInfo.fVariable.getArrayCount() > 0);
          SkDEBUGCODE(
              uniform.fArrayCount = uniformInfo.fVariable.getArrayCount();
              uniform.fType = uniformInfo.fVariable.getType();
          );
  
          if (!(kFragment_GrShaderFlag & uniformInfo.fVisibility)) {
              uniform.fBinding = GrVkUniformHandler::kGeometryBinding;
          } else {
              SkASSERT(kFragment_GrShaderFlag == uniformInfo.fVisibility);
              uniform.fBinding = GrVkUniformHandler::kFragBinding;
          }
          uniform.fOffset = uniformInfo.fUBOffset;
      }
  }
  
  void* GrVkPipelineStateDataManager::getBufferPtrAndMarkDirty(const Uniform& uni) const {
      void* buffer;
      if (GrVkUniformHandler::kGeometryBinding == uni.fBinding) {
          buffer = fGeometryUniformData.get();
          fGeometryUniformsDirty = true;
      } else {
          SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
          buffer = fFragmentUniformData.get();
          fFragmentUniformsDirty = true;
      }
      buffer = static_cast<char*>(buffer)+uni.fOffset;
      return buffer;
  }
  
  void GrVkPipelineStateDataManager::set1i(UniformHandle u, int32_t i) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
      SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      memcpy(buffer, &i, sizeof(int32_t));
  }
  
  void GrVkPipelineStateDataManager::set1iv(UniformHandle u,
                                            int arrayCount,
                                            const int32_t v[]) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
      SkASSERT(arrayCount > 0);
      SkASSERT(arrayCount <= uni.fArrayCount ||
               (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(int32_t) == 4);
      for (int i = 0; i < arrayCount; ++i) {
          const int32_t* curVec = &v[i];
          memcpy(buffer, curVec, sizeof(int32_t));
          buffer = static_cast<char*>(buffer) + 4*sizeof(int32_t);
      }
  }
  
  void GrVkPipelineStateDataManager::set1f(UniformHandle u, float v0) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat_GrSLType || uni.fType == kHalf_GrSLType);
      SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      memcpy(buffer, &v0, sizeof(float));
  }
  
  void GrVkPipelineStateDataManager::set1fv(UniformHandle u,
                                            int arrayCount,
                                            const float v[]) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat_GrSLType || uni.fType == kHalf_GrSLType);
      SkASSERT(arrayCount > 0);
      SkASSERT(arrayCount <= uni.fArrayCount ||
               (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      for (int i = 0; i < arrayCount; ++i) {
          const float* curVec = &v[i];
          memcpy(buffer, curVec, sizeof(float));
          buffer = static_cast<char*>(buffer) + 4*sizeof(float);
      }
  }
  
  void GrVkPipelineStateDataManager::set2f(UniformHandle u, float v0, float v1) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
      SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      float v[2] = { v0, v1 };
      memcpy(buffer, v, 2 * sizeof(float));
  }
  
  void GrVkPipelineStateDataManager::set2fv(UniformHandle u,
                                            int arrayCount,
                                            const float v[]) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
      SkASSERT(arrayCount > 0);
      SkASSERT(arrayCount <= uni.fArrayCount ||
               (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      for (int i = 0; i < arrayCount; ++i) {
          const float* curVec = &v[2 * i];
          memcpy(buffer, curVec, 2 * sizeof(float));
          buffer = static_cast<char*>(buffer) + 4*sizeof(float);
      }
  }
  
  void GrVkPipelineStateDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
      SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      float v[3] = { v0, v1, v2 };
      memcpy(buffer, v, 3 * sizeof(float));
  }
  
  void GrVkPipelineStateDataManager::set3fv(UniformHandle u,
                                            int arrayCount,
                                            const float v[]) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
      SkASSERT(arrayCount > 0);
      SkASSERT(arrayCount <= uni.fArrayCount ||
               (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      for (int i = 0; i < arrayCount; ++i) {
          const float* curVec = &v[3 * i];
          memcpy(buffer, curVec, 3 * sizeof(float));
          buffer = static_cast<char*>(buffer) + 4*sizeof(float);
      }
  }
  
  void GrVkPipelineStateDataManager::set4f(UniformHandle u,
                                           float v0,
                                           float v1,
                                           float v2,
                                           float v3) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
      SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      float v[4] = { v0, v1, v2, v3 };
      memcpy(buffer, v, 4 * sizeof(float));
  }
  
  void GrVkPipelineStateDataManager::set4fv(UniformHandle u,
                                            int arrayCount,
                                            const float v[]) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
      SkASSERT(arrayCount > 0);
      SkASSERT(arrayCount <= uni.fArrayCount ||
               (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  
      void* buffer = this->getBufferPtrAndMarkDirty(uni);
      SkASSERT(sizeof(float) == 4);
      memcpy(buffer, v, arrayCount * 4 * sizeof(float));
  }
  
  void GrVkPipelineStateDataManager::setMatrix2f(UniformHandle u, const float matrix[]) const {
      this->setMatrices<2>(u, 1, matrix);
  }
  
  void GrVkPipelineStateDataManager::setMatrix2fv(UniformHandle u,
                                                  int arrayCount,
                                                  const float m[]) const {
      this->setMatrices<2>(u, arrayCount, m);
  }
  
  void GrVkPipelineStateDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const {
      this->setMatrices<3>(u, 1, matrix);
  }
  
  void GrVkPipelineStateDataManager::setMatrix3fv(UniformHandle u,
                                                  int arrayCount,
                                                  const float m[]) const {
      this->setMatrices<3>(u, arrayCount, m);
  }
  
  void GrVkPipelineStateDataManager::setMatrix4f(UniformHandle u, const float matrix[]) const {
      this->setMatrices<4>(u, 1, matrix);
  }
  
  void GrVkPipelineStateDataManager::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 GrVkPipelineStateDataManager::setMatrices(UniformHandle u,
                                                                        int arrayCount,
                                                                       const float matrices[]) const {
      const Uniform& uni = fUniforms[u.toIndex()];
      SkASSERT(uni.fType == kFloat2x2_GrSLType + (N - 2) ||
               uni.fType == kHalf2x2_GrSLType + (N - 2));
      SkASSERT(arrayCount > 0);
      SkASSERT(arrayCount <= uni.fArrayCount ||
               (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  
      void* buffer;
      if (GrVkUniformHandler::kGeometryBinding == uni.fBinding) {
          buffer = fGeometryUniformData.get();
          fGeometryUniformsDirty = true;
      } else {
          SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
          buffer = fFragmentUniformData.get();
          fFragmentUniformsDirty = true;
      }
  
      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];
              for (int j = 0; j < N; ++j) {
                  memcpy(buffer, &matrix[j * N], 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));
      }
  };
  
  bool GrVkPipelineStateDataManager::uploadUniformBuffers(GrVkGpu* gpu,
                                                          GrVkUniformBuffer* geometryBuffer,
                                                          GrVkUniformBuffer* fragmentBuffer) const {
      bool updatedBuffer = false;
      if (geometryBuffer && fGeometryUniformsDirty) {
          SkAssertResult(geometryBuffer->updateData(gpu, fGeometryUniformData.get(),
                                                    fGeometryUniformSize, &updatedBuffer));
          fGeometryUniformsDirty = false;
      }
      if (fragmentBuffer && fFragmentUniformsDirty) {
          SkAssertResult(fragmentBuffer->updateData(gpu, fFragmentUniformData.get(),
                                                    fFragmentUniformSize, &updatedBuffer));
          fFragmentUniformsDirty = false;
      }
  
      return updatedBuffer;
  }
  