Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(619)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/gpu/vk/GrVkProgramDataManager.cpp

Issue 1718693002: Add vulkan files into skia repo. (Closed) Base URL: https://skia.googlesource.com/skia.git@merge
Patch Set: fix path Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/gpu/vk/GrVkProgramDataManager.h ('k') | src/gpu/vk/GrVkProgramDesc.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/gpu/vk/GrVkProgramDataManager.cpp
diff --git a/src/gpu/vk/GrVkProgramDataManager.cpp b/src/gpu/vk/GrVkProgramDataManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ca03ad0b13cc90cf064ef038472b24775348d09
--- /dev/null
+++ b/src/gpu/vk/GrVkProgramDataManager.cpp
@@ -0,0 +1,315 @@
+/*
+* 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 "GrVkProgramDataManager.h"
+
+#include "GrVkGpu.h"
+#include "GrVkUniformBuffer.h"
+
+GrVkProgramDataManager::GrVkProgramDataManager(const UniformInfoArray& uniforms,
+ uint32_t vertexUniformSize,
+ uint32_t fragmentUniformSize)
+ : fVertexUniformSize(vertexUniformSize)
+ , fFragmentUniformSize(fragmentUniformSize) {
+ fVertexUniformData.reset(vertexUniformSize);
+ 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(GrGLSLShaderVar::kNonArray == uniformInfo.fVariable.getArrayCount() ||
+ uniformInfo.fVariable.getArrayCount() > 0);
+ SkDEBUGCODE(
+ uniform.fArrayCount = uniformInfo.fVariable.getArrayCount();
+ uniform.fType = uniformInfo.fVariable.getType();
+ );
+ uniform.fBinding = uniformInfo.fBinding;
+ uniform.fOffset = uniformInfo.fUBOffset;
+ SkDEBUGCODE(
+ uniform.fSetNumber = uniformInfo.fSetNumber;
+ );
+ }
+}
+
+void GrVkProgramDataManager::set1f(UniformHandle u, float v0) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kFloat_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, &v0, sizeof(float));
+}
+
+void GrVkProgramDataManager::set1fv(UniformHandle u,
+ int arrayCount,
+ const float v[]) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kFloat_GrSLType);
+ SkASSERT(arrayCount > 0);
+ SkASSERT(arrayCount <= uni.fArrayCount ||
+ (1 == arrayCount && 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, v, arrayCount * sizeof(float));
+}
+
+void GrVkProgramDataManager::set2f(UniformHandle u, float v0, float v1) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kVec2f_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);
+ float v[2] = { v0, v1 };
+ memcpy(buffer, v, 2 * sizeof(float));
+}
+
+void GrVkProgramDataManager::set2fv(UniformHandle u,
+ int arrayCount,
+ const float v[]) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kVec2f_GrSLType);
+ SkASSERT(arrayCount > 0);
+ SkASSERT(arrayCount <= uni.fArrayCount ||
+ (1 == arrayCount && 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, v, arrayCount * 2* sizeof(float));
+}
+
+void GrVkProgramDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kVec3f_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);
+ float v[3] = { v0, v1, v2 };
+ memcpy(buffer, v, 3 * sizeof(float));
+}
+
+void GrVkProgramDataManager::set3fv(UniformHandle u,
+ int arrayCount,
+ const float v[]) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kVec3f_GrSLType);
+ SkASSERT(arrayCount > 0);
+ SkASSERT(arrayCount <= uni.fArrayCount ||
+ (1 == arrayCount && 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, v, arrayCount * 3 * sizeof(float));
+}
+
+void GrVkProgramDataManager::set4f(UniformHandle u, float v0, float v1, float v2, float v3) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kVec4f_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);
+ float v[4] = { v0, v1, v2, v3 };
+ memcpy(buffer, v, 4 * sizeof(float));
+}
+
+void GrVkProgramDataManager::set4fv(UniformHandle u,
+ int arrayCount,
+ const float v[]) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kVec4f_GrSLType);
+ SkASSERT(arrayCount > 0);
+ SkASSERT(arrayCount <= uni.fArrayCount ||
+ (1 == arrayCount && 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, 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::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* 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::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));
+}
+
+void GrVkProgramDataManager::setMatrix4fv(UniformHandle u,
+ int arrayCount,
+ const float matrices[]) const {
+ const Uniform& uni = fUniforms[u.toIndex()];
+ SkASSERT(uni.fType == kMat44f_GrSLType);
+ SkASSERT(arrayCount > 0);
+ SkASSERT(arrayCount <= uni.fArrayCount ||
+ (1 == arrayCount && 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, matrices, arrayCount * 16 * sizeof(float));
+}
+
+void GrVkProgramDataManager::uploadUniformBuffers(const GrVkGpu* gpu,
+ GrVkUniformBuffer* vertexBuffer,
+ GrVkUniformBuffer* fragmentBuffer) const {
+ if (vertexBuffer) {
+ vertexBuffer->addMemoryBarrier(gpu,
+ VK_ACCESS_UNIFORM_READ_BIT,
+ VK_ACCESS_HOST_WRITE_BIT,
+ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+ VK_PIPELINE_STAGE_HOST_BIT,
+ false);
+ SkAssertResult(vertexBuffer->updateData(gpu, fVertexUniformData.get(), fVertexUniformSize));
+ }
+
+ if (fragmentBuffer) {
+ fragmentBuffer->addMemoryBarrier(gpu,
+ VK_ACCESS_UNIFORM_READ_BIT,
+ VK_ACCESS_HOST_WRITE_BIT,
+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+ VK_PIPELINE_STAGE_HOST_BIT,
+ false);
+ SkAssertResult(fragmentBuffer->updateData(gpu, fFragmentUniformData.get(),
+ fFragmentUniformSize));
+ }
+}
« no previous file with comments | « src/gpu/vk/GrVkProgramDataManager.h ('k') | src/gpu/vk/GrVkProgramDesc.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698