| /* |
| * Copyright 2020 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/gpu/GrUniformDataManager.h" |
| |
| #include "src/gpu/GrShaderVar.h" |
| |
| // ensure that these types are the sizes the uniform data is expecting |
| static_assert(sizeof(int32_t) == 4); |
| static_assert(sizeof(float) == 4); |
| |
| GrUniformDataManager::GrUniformDataManager(uint32_t uniformCount, uint32_t uniformSize) |
| : fUniformSize(uniformSize) |
| , fUniformsDirty(false) { |
| fUniformData.reset(uniformSize); |
| fUniforms.push_back_n(uniformCount); |
| // subclasses fill in the uniforms in their constructor |
| } |
| |
| void* GrUniformDataManager::getBufferPtrAndMarkDirty(const Uniform& uni) const { |
| fUniformsDirty = true; |
| return static_cast<char*>(fUniformData.get())+uni.fOffset; |
| } |
| |
| void GrUniformDataManager::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 GrUniformDataManager::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); |
| 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 GrUniformDataManager::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); |
| memcpy(buffer, &v0, sizeof(float)); |
| } |
| |
| void GrUniformDataManager::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); |
| 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 GrUniformDataManager::set2i(UniformHandle u, int32_t i0, int32_t i1) const { |
| const Uniform& uni = fUniforms[u.toIndex()]; |
| SkASSERT(uni.fType == kInt2_GrSLType || uni.fType == kShort2_GrSLType); |
| SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount); |
| void* buffer = this->getBufferPtrAndMarkDirty(uni); |
| int32_t v[2] = { i0, i1 }; |
| memcpy(buffer, v, 2 * sizeof(int32_t)); |
| } |
| |
| void GrUniformDataManager::set2iv(UniformHandle u, |
| int arrayCount, |
| const int32_t v[]) const { |
| const Uniform& uni = fUniforms[u.toIndex()]; |
| SkASSERT(uni.fType == kInt2_GrSLType || uni.fType == kShort2_GrSLType); |
| SkASSERT(arrayCount > 0); |
| SkASSERT(arrayCount <= uni.fArrayCount || |
| (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount)); |
| |
| void* buffer = this->getBufferPtrAndMarkDirty(uni); |
| for (int i = 0; i < arrayCount; ++i) { |
| const int32_t* curVec = &v[2 * i]; |
| memcpy(buffer, curVec, 2 * sizeof(int32_t)); |
| buffer = static_cast<char*>(buffer) + 4*sizeof(int32_t); |
| } |
| } |
| |
| void GrUniformDataManager::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); |
| float v[2] = { v0, v1 }; |
| memcpy(buffer, v, 2 * sizeof(float)); |
| } |
| |
| void GrUniformDataManager::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); |
| 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 GrUniformDataManager::set3i(UniformHandle u, |
| int32_t i0, |
| int32_t i1, |
| int32_t i2) const { |
| const Uniform& uni = fUniforms[u.toIndex()]; |
| SkASSERT(uni.fType == kInt3_GrSLType || uni.fType == kShort3_GrSLType); |
| SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount); |
| void* buffer = this->getBufferPtrAndMarkDirty(uni); |
| int32_t v[3] = { i0, i1, i2 }; |
| memcpy(buffer, v, 3 * sizeof(int32_t)); |
| } |
| |
| void GrUniformDataManager::set3iv(UniformHandle u, |
| int arrayCount, |
| const int32_t v[]) const { |
| const Uniform& uni = fUniforms[u.toIndex()]; |
| SkASSERT(uni.fType == kInt3_GrSLType || uni.fType == kShort3_GrSLType); |
| SkASSERT(arrayCount > 0); |
| SkASSERT(arrayCount <= uni.fArrayCount || |
| (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount)); |
| |
| void* buffer = this->getBufferPtrAndMarkDirty(uni); |
| for (int i = 0; i < arrayCount; ++i) { |
| const int32_t* curVec = &v[3 * i]; |
| memcpy(buffer, curVec, 3 * sizeof(int32_t)); |
| buffer = static_cast<char*>(buffer) + 4*sizeof(int32_t); |
| } |
| } |
| |
| void GrUniformDataManager::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); |
| float v[3] = { v0, v1, v2 }; |
| memcpy(buffer, v, 3 * sizeof(float)); |
| } |
| |
| void GrUniformDataManager::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); |
| 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 GrUniformDataManager::set4i(UniformHandle u, |
| int32_t i0, |
| int32_t i1, |
| int32_t i2, |
| int32_t i3) const { |
| const Uniform& uni = fUniforms[u.toIndex()]; |
| SkASSERT(uni.fType == kInt4_GrSLType || uni.fType == kShort4_GrSLType); |
| SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount); |
| void* buffer = this->getBufferPtrAndMarkDirty(uni); |
| int32_t v[4] = { i0, i1, i2, i3 }; |
| memcpy(buffer, v, 4 * sizeof(int32_t)); |
| } |
| |
| void GrUniformDataManager::set4iv(UniformHandle u, |
| int arrayCount, |
| const int32_t v[]) const { |
| const Uniform& uni = fUniforms[u.toIndex()]; |
| SkASSERT(uni.fType == kInt4_GrSLType || uni.fType == kShort4_GrSLType); |
| SkASSERT(arrayCount > 0); |
| SkASSERT(arrayCount <= uni.fArrayCount || |
| (1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount)); |
| |
| void* buffer = this->getBufferPtrAndMarkDirty(uni); |
| memcpy(buffer, v, arrayCount * 4 * sizeof(int32_t)); |
| } |
| |
| void GrUniformDataManager::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); |
| float v[4] = { v0, v1, v2, v3 }; |
| memcpy(buffer, v, 4 * sizeof(float)); |
| } |
| |
| void GrUniformDataManager::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); |
| memcpy(buffer, v, arrayCount * 4 * sizeof(float)); |
| } |
| |
| void GrUniformDataManager::setMatrix2f(UniformHandle u, const float matrix[]) const { |
| this->setMatrices<2>(u, 1, matrix); |
| } |
| |
| void GrUniformDataManager::setMatrix2fv(UniformHandle u, int arrayCount, const float m[]) const { |
| this->setMatrices<2>(u, arrayCount, m); |
| } |
| |
| void GrUniformDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const { |
| this->setMatrices<3>(u, 1, matrix); |
| } |
| |
| void GrUniformDataManager::setMatrix3fv(UniformHandle u, int arrayCount, const float m[]) const { |
| this->setMatrices<3>(u, arrayCount, m); |
| } |
| |
| void GrUniformDataManager::setMatrix4f(UniformHandle u, const float matrix[]) const { |
| this->setMatrices<4>(u, 1, matrix); |
| } |
| |
| void GrUniformDataManager::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 GrUniformDataManager::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 = fUniformData.get(); |
| fUniformsDirty = 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[]) { |
| 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[]) { |
| buffer = static_cast<char*>(buffer) + uniformOffset; |
| memcpy(buffer, matrices, count * 16 * sizeof(float)); |
| } |
| }; |
| |