GrVkPipelineStateDataManager.cpp 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378
  1. /*
  2. * Copyright 2016 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #include "src/gpu/vk/GrVkPipelineStateDataManager.h"
  8. #include "src/gpu/vk/GrVkGpu.h"
  9. #include "src/gpu/vk/GrVkUniformBuffer.h"
  10. GrVkPipelineStateDataManager::GrVkPipelineStateDataManager(const UniformInfoArray& uniforms,
  11. uint32_t geometryUniformSize,
  12. uint32_t fragmentUniformSize)
  13. : fGeometryUniformSize(geometryUniformSize)
  14. , fFragmentUniformSize(fragmentUniformSize)
  15. , fGeometryUniformsDirty(false)
  16. , fFragmentUniformsDirty(false) {
  17. fGeometryUniformData.reset(geometryUniformSize);
  18. fFragmentUniformData.reset(fragmentUniformSize);
  19. int count = uniforms.count();
  20. fUniforms.push_back_n(count);
  21. // We must add uniforms in same order is the UniformInfoArray so that UniformHandles already
  22. // owned by other objects will still match up here.
  23. for (int i = 0; i < count; i++) {
  24. Uniform& uniform = fUniforms[i];
  25. const GrVkUniformHandler::UniformInfo uniformInfo = uniforms[i];
  26. SkASSERT(GrShaderVar::kNonArray == uniformInfo.fVariable.getArrayCount() ||
  27. uniformInfo.fVariable.getArrayCount() > 0);
  28. SkDEBUGCODE(
  29. uniform.fArrayCount = uniformInfo.fVariable.getArrayCount();
  30. uniform.fType = uniformInfo.fVariable.getType();
  31. )
  32. if (!(kFragment_GrShaderFlag & uniformInfo.fVisibility)) {
  33. uniform.fBinding = GrVkUniformHandler::kGeometryBinding;
  34. } else {
  35. SkASSERT(kFragment_GrShaderFlag == uniformInfo.fVisibility);
  36. uniform.fBinding = GrVkUniformHandler::kFragBinding;
  37. }
  38. uniform.fOffset = uniformInfo.fUBOffset;
  39. }
  40. }
  41. void* GrVkPipelineStateDataManager::getBufferPtrAndMarkDirty(const Uniform& uni) const {
  42. void* buffer;
  43. if (GrVkUniformHandler::kGeometryBinding == uni.fBinding) {
  44. buffer = fGeometryUniformData.get();
  45. fGeometryUniformsDirty = true;
  46. } else {
  47. SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
  48. buffer = fFragmentUniformData.get();
  49. fFragmentUniformsDirty = true;
  50. }
  51. buffer = static_cast<char*>(buffer)+uni.fOffset;
  52. return buffer;
  53. }
  54. void GrVkPipelineStateDataManager::set1i(UniformHandle u, int32_t i) const {
  55. const Uniform& uni = fUniforms[u.toIndex()];
  56. SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
  57. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  58. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  59. memcpy(buffer, &i, sizeof(int32_t));
  60. }
  61. void GrVkPipelineStateDataManager::set1iv(UniformHandle u,
  62. int arrayCount,
  63. const int32_t v[]) const {
  64. const Uniform& uni = fUniforms[u.toIndex()];
  65. SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
  66. SkASSERT(arrayCount > 0);
  67. SkASSERT(arrayCount <= uni.fArrayCount ||
  68. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  69. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  70. SkASSERT(sizeof(int32_t) == 4);
  71. for (int i = 0; i < arrayCount; ++i) {
  72. const int32_t* curVec = &v[i];
  73. memcpy(buffer, curVec, sizeof(int32_t));
  74. buffer = static_cast<char*>(buffer) + 4*sizeof(int32_t);
  75. }
  76. }
  77. void GrVkPipelineStateDataManager::set1f(UniformHandle u, float v0) const {
  78. const Uniform& uni = fUniforms[u.toIndex()];
  79. SkASSERT(uni.fType == kFloat_GrSLType || uni.fType == kHalf_GrSLType);
  80. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  81. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  82. SkASSERT(sizeof(float) == 4);
  83. memcpy(buffer, &v0, sizeof(float));
  84. }
  85. void GrVkPipelineStateDataManager::set1fv(UniformHandle u,
  86. int arrayCount,
  87. const float v[]) const {
  88. const Uniform& uni = fUniforms[u.toIndex()];
  89. SkASSERT(uni.fType == kFloat_GrSLType || uni.fType == kHalf_GrSLType);
  90. SkASSERT(arrayCount > 0);
  91. SkASSERT(arrayCount <= uni.fArrayCount ||
  92. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  93. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  94. SkASSERT(sizeof(float) == 4);
  95. for (int i = 0; i < arrayCount; ++i) {
  96. const float* curVec = &v[i];
  97. memcpy(buffer, curVec, sizeof(float));
  98. buffer = static_cast<char*>(buffer) + 4*sizeof(float);
  99. }
  100. }
  101. void GrVkPipelineStateDataManager::set2i(UniformHandle u, int32_t i0, int32_t i1) const {
  102. const Uniform& uni = fUniforms[u.toIndex()];
  103. SkASSERT(uni.fType == kInt2_GrSLType || uni.fType == kShort2_GrSLType);
  104. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  105. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  106. int32_t v[2] = { i0, i1 };
  107. memcpy(buffer, v, 2 * sizeof(int32_t));
  108. }
  109. void GrVkPipelineStateDataManager::set2iv(UniformHandle u,
  110. int arrayCount,
  111. const int32_t v[]) const {
  112. const Uniform& uni = fUniforms[u.toIndex()];
  113. SkASSERT(uni.fType == kInt2_GrSLType || uni.fType == kShort2_GrSLType);
  114. SkASSERT(arrayCount > 0);
  115. SkASSERT(arrayCount <= uni.fArrayCount ||
  116. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  117. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  118. SkASSERT(sizeof(int32_t) == 4);
  119. for (int i = 0; i < arrayCount; ++i) {
  120. const int32_t* curVec = &v[2 * i];
  121. memcpy(buffer, curVec, 2 * sizeof(int32_t));
  122. buffer = static_cast<char*>(buffer) + 4*sizeof(int32_t);
  123. }
  124. }
  125. void GrVkPipelineStateDataManager::set2f(UniformHandle u, float v0, float v1) const {
  126. const Uniform& uni = fUniforms[u.toIndex()];
  127. SkASSERT(uni.fType == kFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
  128. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  129. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  130. SkASSERT(sizeof(float) == 4);
  131. float v[2] = { v0, v1 };
  132. memcpy(buffer, v, 2 * sizeof(float));
  133. }
  134. void GrVkPipelineStateDataManager::set2fv(UniformHandle u,
  135. int arrayCount,
  136. const float v[]) const {
  137. const Uniform& uni = fUniforms[u.toIndex()];
  138. SkASSERT(uni.fType == kFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
  139. SkASSERT(arrayCount > 0);
  140. SkASSERT(arrayCount <= uni.fArrayCount ||
  141. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  142. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  143. SkASSERT(sizeof(float) == 4);
  144. for (int i = 0; i < arrayCount; ++i) {
  145. const float* curVec = &v[2 * i];
  146. memcpy(buffer, curVec, 2 * sizeof(float));
  147. buffer = static_cast<char*>(buffer) + 4*sizeof(float);
  148. }
  149. }
  150. void GrVkPipelineStateDataManager::set3i(UniformHandle u,
  151. int32_t i0,
  152. int32_t i1,
  153. int32_t i2) const {
  154. const Uniform& uni = fUniforms[u.toIndex()];
  155. SkASSERT(uni.fType == kInt3_GrSLType || uni.fType == kShort3_GrSLType);
  156. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  157. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  158. int32_t v[3] = { i0, i1, i2 };
  159. memcpy(buffer, v, 3 * sizeof(int32_t));
  160. }
  161. void GrVkPipelineStateDataManager::set3iv(UniformHandle u,
  162. int arrayCount,
  163. const int32_t v[]) const {
  164. const Uniform& uni = fUniforms[u.toIndex()];
  165. SkASSERT(uni.fType == kInt3_GrSLType || uni.fType == kShort3_GrSLType);
  166. SkASSERT(arrayCount > 0);
  167. SkASSERT(arrayCount <= uni.fArrayCount ||
  168. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  169. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  170. SkASSERT(sizeof(int32_t) == 4);
  171. for (int i = 0; i < arrayCount; ++i) {
  172. const int32_t* curVec = &v[3 * i];
  173. memcpy(buffer, curVec, 3 * sizeof(int32_t));
  174. buffer = static_cast<char*>(buffer) + 4*sizeof(int32_t);
  175. }
  176. }
  177. void GrVkPipelineStateDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
  178. const Uniform& uni = fUniforms[u.toIndex()];
  179. SkASSERT(uni.fType == kFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
  180. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  181. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  182. SkASSERT(sizeof(float) == 4);
  183. float v[3] = { v0, v1, v2 };
  184. memcpy(buffer, v, 3 * sizeof(float));
  185. }
  186. void GrVkPipelineStateDataManager::set3fv(UniformHandle u,
  187. int arrayCount,
  188. const float v[]) const {
  189. const Uniform& uni = fUniforms[u.toIndex()];
  190. SkASSERT(uni.fType == kFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
  191. SkASSERT(arrayCount > 0);
  192. SkASSERT(arrayCount <= uni.fArrayCount ||
  193. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  194. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  195. SkASSERT(sizeof(float) == 4);
  196. for (int i = 0; i < arrayCount; ++i) {
  197. const float* curVec = &v[3 * i];
  198. memcpy(buffer, curVec, 3 * sizeof(float));
  199. buffer = static_cast<char*>(buffer) + 4*sizeof(float);
  200. }
  201. }
  202. void GrVkPipelineStateDataManager::set4i(UniformHandle u,
  203. int32_t i0,
  204. int32_t i1,
  205. int32_t i2,
  206. int32_t i3) const {
  207. const Uniform& uni = fUniforms[u.toIndex()];
  208. SkASSERT(uni.fType == kInt4_GrSLType || uni.fType == kShort4_GrSLType);
  209. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  210. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  211. int32_t v[4] = { i0, i1, i2, i3 };
  212. memcpy(buffer, v, 4 * sizeof(int32_t));
  213. }
  214. void GrVkPipelineStateDataManager::set4iv(UniformHandle u,
  215. int arrayCount,
  216. const int32_t v[]) const {
  217. const Uniform& uni = fUniforms[u.toIndex()];
  218. SkASSERT(uni.fType == kInt4_GrSLType || uni.fType == kShort4_GrSLType);
  219. SkASSERT(arrayCount > 0);
  220. SkASSERT(arrayCount <= uni.fArrayCount ||
  221. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  222. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  223. SkASSERT(sizeof(int32_t) == 4);
  224. for (int i = 0; i < arrayCount; ++i) {
  225. const int32_t* curVec = &v[4 * i];
  226. memcpy(buffer, curVec, 4 * sizeof(int32_t));
  227. buffer = static_cast<char*>(buffer) + 4*sizeof(int32_t);
  228. }
  229. }
  230. void GrVkPipelineStateDataManager::set4f(UniformHandle u,
  231. float v0,
  232. float v1,
  233. float v2,
  234. float v3) const {
  235. const Uniform& uni = fUniforms[u.toIndex()];
  236. SkASSERT(uni.fType == kFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
  237. SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
  238. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  239. SkASSERT(sizeof(float) == 4);
  240. float v[4] = { v0, v1, v2, v3 };
  241. memcpy(buffer, v, 4 * sizeof(float));
  242. }
  243. void GrVkPipelineStateDataManager::set4fv(UniformHandle u,
  244. int arrayCount,
  245. const float v[]) const {
  246. const Uniform& uni = fUniforms[u.toIndex()];
  247. SkASSERT(uni.fType == kFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
  248. SkASSERT(arrayCount > 0);
  249. SkASSERT(arrayCount <= uni.fArrayCount ||
  250. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  251. void* buffer = this->getBufferPtrAndMarkDirty(uni);
  252. SkASSERT(sizeof(float) == 4);
  253. memcpy(buffer, v, arrayCount * 4 * sizeof(float));
  254. }
  255. void GrVkPipelineStateDataManager::setMatrix2f(UniformHandle u, const float matrix[]) const {
  256. this->setMatrices<2>(u, 1, matrix);
  257. }
  258. void GrVkPipelineStateDataManager::setMatrix2fv(UniformHandle u,
  259. int arrayCount,
  260. const float m[]) const {
  261. this->setMatrices<2>(u, arrayCount, m);
  262. }
  263. void GrVkPipelineStateDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const {
  264. this->setMatrices<3>(u, 1, matrix);
  265. }
  266. void GrVkPipelineStateDataManager::setMatrix3fv(UniformHandle u,
  267. int arrayCount,
  268. const float m[]) const {
  269. this->setMatrices<3>(u, arrayCount, m);
  270. }
  271. void GrVkPipelineStateDataManager::setMatrix4f(UniformHandle u, const float matrix[]) const {
  272. this->setMatrices<4>(u, 1, matrix);
  273. }
  274. void GrVkPipelineStateDataManager::setMatrix4fv(UniformHandle u,
  275. int arrayCount,
  276. const float m[]) const {
  277. this->setMatrices<4>(u, arrayCount, m);
  278. }
  279. template<int N> struct set_uniform_matrix;
  280. template<int N> inline void GrVkPipelineStateDataManager::setMatrices(UniformHandle u,
  281. int arrayCount,
  282. const float matrices[]) const {
  283. const Uniform& uni = fUniforms[u.toIndex()];
  284. SkASSERT(uni.fType == kFloat2x2_GrSLType + (N - 2) ||
  285. uni.fType == kHalf2x2_GrSLType + (N - 2));
  286. SkASSERT(arrayCount > 0);
  287. SkASSERT(arrayCount <= uni.fArrayCount ||
  288. (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
  289. void* buffer;
  290. if (GrVkUniformHandler::kGeometryBinding == uni.fBinding) {
  291. buffer = fGeometryUniformData.get();
  292. fGeometryUniformsDirty = true;
  293. } else {
  294. SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding);
  295. buffer = fFragmentUniformData.get();
  296. fFragmentUniformsDirty = true;
  297. }
  298. set_uniform_matrix<N>::set(buffer, uni.fOffset, arrayCount, matrices);
  299. }
  300. template<int N> struct set_uniform_matrix {
  301. inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
  302. GR_STATIC_ASSERT(sizeof(float) == 4);
  303. buffer = static_cast<char*>(buffer) + uniformOffset;
  304. for (int i = 0; i < count; ++i) {
  305. const float* matrix = &matrices[N * N * i];
  306. for (int j = 0; j < N; ++j) {
  307. memcpy(buffer, &matrix[j * N], N * sizeof(float));
  308. buffer = static_cast<char*>(buffer) + 4 * sizeof(float);
  309. }
  310. }
  311. }
  312. };
  313. template<> struct set_uniform_matrix<4> {
  314. inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
  315. GR_STATIC_ASSERT(sizeof(float) == 4);
  316. buffer = static_cast<char*>(buffer) + uniformOffset;
  317. memcpy(buffer, matrices, count * 16 * sizeof(float));
  318. }
  319. };
  320. bool GrVkPipelineStateDataManager::uploadUniformBuffers(GrVkGpu* gpu,
  321. GrVkUniformBuffer* geometryBuffer,
  322. GrVkUniformBuffer* fragmentBuffer) const {
  323. bool updatedBuffer = false;
  324. if (geometryBuffer && fGeometryUniformsDirty) {
  325. SkAssertResult(geometryBuffer->updateData(gpu, fGeometryUniformData.get(),
  326. fGeometryUniformSize, &updatedBuffer));
  327. fGeometryUniformsDirty = false;
  328. }
  329. if (fragmentBuffer && fFragmentUniformsDirty) {
  330. SkAssertResult(fragmentBuffer->updateData(gpu, fFragmentUniformData.get(),
  331. fFragmentUniformSize, &updatedBuffer));
  332. fFragmentUniformsDirty = false;
  333. }
  334. return updatedBuffer;
  335. }