OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2016 Google Inc. | 2 * Copyright 2016 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "GrVkProgramDataManager.h" | 8 #include "GrVkProgramDataManager.h" |
9 | 9 |
10 #include "GrVkGpu.h" | 10 #include "GrVkGpu.h" |
11 #include "GrVkUniformBuffer.h" | 11 #include "GrVkUniformBuffer.h" |
12 | 12 |
13 GrVkProgramDataManager::GrVkProgramDataManager(const UniformInfoArray& uniforms, | 13 GrVkProgramDataManager::GrVkProgramDataManager(const UniformInfoArray& uniforms, |
14 uint32_t vertexUniformSize, | 14 uint32_t vertexUniformSize, |
15 uint32_t fragmentUniformSize) | 15 uint32_t fragmentUniformSize) |
16 : fVertexUniformSize(vertexUniformSize) | 16 : fVertexUniformSize(vertexUniformSize) |
17 , fFragmentUniformSize(fragmentUniformSize) { | 17 , fFragmentUniformSize(fragmentUniformSize) |
| 18 , fVertexUniformsDirty(false) |
| 19 , fFragmentUniformsDirty(false) { |
18 fVertexUniformData.reset(vertexUniformSize); | 20 fVertexUniformData.reset(vertexUniformSize); |
19 fFragmentUniformData.reset(fragmentUniformSize); | 21 fFragmentUniformData.reset(fragmentUniformSize); |
20 int count = uniforms.count(); | 22 int count = uniforms.count(); |
21 fUniforms.push_back_n(count); | 23 fUniforms.push_back_n(count); |
22 // We must add uniforms in same order is the UniformInfoArray so that Unifor
mHandles already | 24 // We must add uniforms in same order is the UniformInfoArray so that Unifor
mHandles already |
23 // owned by other objects will still match up here. | 25 // owned by other objects will still match up here. |
24 for (int i = 0; i < count; i++) { | 26 for (int i = 0; i < count; i++) { |
25 Uniform& uniform = fUniforms[i]; | 27 Uniform& uniform = fUniforms[i]; |
26 const GrVkUniformHandler::UniformInfo uniformInfo = uniforms[i]; | 28 const GrVkUniformHandler::UniformInfo uniformInfo = uniforms[i]; |
27 SkASSERT(GrGLSLShaderVar::kNonArray == uniformInfo.fVariable.getArrayCou
nt() || | 29 SkASSERT(GrGLSLShaderVar::kNonArray == uniformInfo.fVariable.getArrayCou
nt() || |
28 uniformInfo.fVariable.getArrayCount() > 0); | 30 uniformInfo.fVariable.getArrayCount() > 0); |
29 SkDEBUGCODE( | 31 SkDEBUGCODE( |
30 uniform.fArrayCount = uniformInfo.fVariable.getArrayCount(); | 32 uniform.fArrayCount = uniformInfo.fVariable.getArrayCount(); |
31 uniform.fType = uniformInfo.fVariable.getType(); | 33 uniform.fType = uniformInfo.fVariable.getType(); |
32 ); | 34 ); |
33 uniform.fBinding = uniformInfo.fBinding; | 35 uniform.fBinding = uniformInfo.fBinding; |
34 uniform.fOffset = uniformInfo.fUBOffset; | 36 uniform.fOffset = uniformInfo.fUBOffset; |
35 SkDEBUGCODE( | 37 SkDEBUGCODE( |
36 uniform.fSetNumber = uniformInfo.fSetNumber; | 38 uniform.fSetNumber = uniformInfo.fSetNumber; |
37 ); | 39 ); |
38 } | 40 } |
39 } | 41 } |
40 | 42 |
| 43 void* GrVkProgramDataManager::getBufferPtrAndMarkDirty(const Uniform& uni) const
{ |
| 44 void* buffer; |
| 45 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { |
| 46 buffer = fVertexUniformData.get(); |
| 47 fVertexUniformsDirty = true; |
| 48 } |
| 49 else { |
| 50 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); |
| 51 buffer = fFragmentUniformData.get(); |
| 52 fFragmentUniformsDirty = true; |
| 53 } |
| 54 buffer = static_cast<char*>(buffer)+uni.fOffset; |
| 55 return buffer; |
| 56 } |
| 57 |
41 void GrVkProgramDataManager::set1f(UniformHandle u, float v0) const { | 58 void GrVkProgramDataManager::set1f(UniformHandle u, float v0) const { |
42 const Uniform& uni = fUniforms[u.toIndex()]; | 59 const Uniform& uni = fUniforms[u.toIndex()]; |
43 SkASSERT(uni.fType == kFloat_GrSLType); | 60 SkASSERT(uni.fType == kFloat_GrSLType); |
44 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 61 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
45 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 62 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
46 void* buffer; | 63 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
47 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
48 buffer = fVertexUniformData.get(); | |
49 } else { | |
50 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
51 buffer = fFragmentUniformData.get(); | |
52 } | |
53 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
54 SkASSERT(sizeof(float) == 4); | 64 SkASSERT(sizeof(float) == 4); |
55 memcpy(buffer, &v0, sizeof(float)); | 65 memcpy(buffer, &v0, sizeof(float)); |
56 } | 66 } |
57 | 67 |
58 void GrVkProgramDataManager::set1fv(UniformHandle u, | 68 void GrVkProgramDataManager::set1fv(UniformHandle u, |
59 int arrayCount, | 69 int arrayCount, |
60 const float v[]) const { | 70 const float v[]) const { |
61 const Uniform& uni = fUniforms[u.toIndex()]; | 71 const Uniform& uni = fUniforms[u.toIndex()]; |
62 SkASSERT(uni.fType == kFloat_GrSLType); | 72 SkASSERT(uni.fType == kFloat_GrSLType); |
63 SkASSERT(arrayCount > 0); | 73 SkASSERT(arrayCount > 0); |
64 SkASSERT(arrayCount <= uni.fArrayCount || | 74 SkASSERT(arrayCount <= uni.fArrayCount || |
65 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 75 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
66 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 76 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
67 | 77 |
68 void* buffer; | 78 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
69 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
70 buffer = fVertexUniformData.get(); | |
71 } else { | |
72 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
73 buffer = fFragmentUniformData.get(); | |
74 } | |
75 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
76 SkASSERT(sizeof(float) == 4); | 79 SkASSERT(sizeof(float) == 4); |
77 for (int i = 0; i < arrayCount; ++i) { | 80 for (int i = 0; i < arrayCount; ++i) { |
78 const float* curVec = &v[i]; | 81 const float* curVec = &v[i]; |
79 memcpy(buffer, curVec, sizeof(float)); | 82 memcpy(buffer, curVec, sizeof(float)); |
80 buffer = static_cast<char*>(buffer) + 4*sizeof(float); | 83 buffer = static_cast<char*>(buffer) + 4*sizeof(float); |
81 } | 84 } |
82 } | 85 } |
83 | 86 |
84 void GrVkProgramDataManager::set2f(UniformHandle u, float v0, float v1) const { | 87 void GrVkProgramDataManager::set2f(UniformHandle u, float v0, float v1) const { |
85 const Uniform& uni = fUniforms[u.toIndex()]; | 88 const Uniform& uni = fUniforms[u.toIndex()]; |
86 SkASSERT(uni.fType == kVec2f_GrSLType); | 89 SkASSERT(uni.fType == kVec2f_GrSLType); |
87 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 90 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
88 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 91 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
89 void* buffer; | 92 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
90 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
91 buffer = fVertexUniformData.get(); | |
92 } else { | |
93 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
94 buffer = fFragmentUniformData.get(); | |
95 } | |
96 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
97 SkASSERT(sizeof(float) == 4); | 93 SkASSERT(sizeof(float) == 4); |
98 float v[2] = { v0, v1 }; | 94 float v[2] = { v0, v1 }; |
99 memcpy(buffer, v, 2 * sizeof(float)); | 95 memcpy(buffer, v, 2 * sizeof(float)); |
100 } | 96 } |
101 | 97 |
102 void GrVkProgramDataManager::set2fv(UniformHandle u, | 98 void GrVkProgramDataManager::set2fv(UniformHandle u, |
103 int arrayCount, | 99 int arrayCount, |
104 const float v[]) const { | 100 const float v[]) const { |
105 const Uniform& uni = fUniforms[u.toIndex()]; | 101 const Uniform& uni = fUniforms[u.toIndex()]; |
106 SkASSERT(uni.fType == kVec2f_GrSLType); | 102 SkASSERT(uni.fType == kVec2f_GrSLType); |
107 SkASSERT(arrayCount > 0); | 103 SkASSERT(arrayCount > 0); |
108 SkASSERT(arrayCount <= uni.fArrayCount || | 104 SkASSERT(arrayCount <= uni.fArrayCount || |
109 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 105 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
110 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 106 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
111 | 107 |
112 void* buffer; | 108 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
113 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
114 buffer = fVertexUniformData.get(); | |
115 } else { | |
116 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
117 buffer = fFragmentUniformData.get(); | |
118 } | |
119 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
120 SkASSERT(sizeof(float) == 4); | 109 SkASSERT(sizeof(float) == 4); |
121 for (int i = 0; i < arrayCount; ++i) { | 110 for (int i = 0; i < arrayCount; ++i) { |
122 const float* curVec = &v[2 * i]; | 111 const float* curVec = &v[2 * i]; |
123 memcpy(buffer, curVec, 2 * sizeof(float)); | 112 memcpy(buffer, curVec, 2 * sizeof(float)); |
124 buffer = static_cast<char*>(buffer) + 4*sizeof(float); | 113 buffer = static_cast<char*>(buffer) + 4*sizeof(float); |
125 } | 114 } |
126 } | 115 } |
127 | 116 |
128 void GrVkProgramDataManager::set3f(UniformHandle u, float v0, float v1, float v2
) const { | 117 void GrVkProgramDataManager::set3f(UniformHandle u, float v0, float v1, float v2
) const { |
129 const Uniform& uni = fUniforms[u.toIndex()]; | 118 const Uniform& uni = fUniforms[u.toIndex()]; |
130 SkASSERT(uni.fType == kVec3f_GrSLType); | 119 SkASSERT(uni.fType == kVec3f_GrSLType); |
131 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 120 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
132 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 121 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
133 void* buffer; | 122 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
134 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
135 buffer = fVertexUniformData.get(); | |
136 } else { | |
137 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
138 buffer = fFragmentUniformData.get(); | |
139 } | |
140 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
141 SkASSERT(sizeof(float) == 4); | 123 SkASSERT(sizeof(float) == 4); |
142 float v[3] = { v0, v1, v2 }; | 124 float v[3] = { v0, v1, v2 }; |
143 memcpy(buffer, v, 3 * sizeof(float)); | 125 memcpy(buffer, v, 3 * sizeof(float)); |
144 } | 126 } |
145 | 127 |
146 void GrVkProgramDataManager::set3fv(UniformHandle u, | 128 void GrVkProgramDataManager::set3fv(UniformHandle u, |
147 int arrayCount, | 129 int arrayCount, |
148 const float v[]) const { | 130 const float v[]) const { |
149 const Uniform& uni = fUniforms[u.toIndex()]; | 131 const Uniform& uni = fUniforms[u.toIndex()]; |
150 SkASSERT(uni.fType == kVec3f_GrSLType); | 132 SkASSERT(uni.fType == kVec3f_GrSLType); |
151 SkASSERT(arrayCount > 0); | 133 SkASSERT(arrayCount > 0); |
152 SkASSERT(arrayCount <= uni.fArrayCount || | 134 SkASSERT(arrayCount <= uni.fArrayCount || |
153 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 135 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
154 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 136 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
155 | 137 |
156 void* buffer; | 138 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
157 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
158 buffer = fVertexUniformData.get(); | |
159 } else { | |
160 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
161 buffer = fFragmentUniformData.get(); | |
162 } | |
163 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
164 SkASSERT(sizeof(float) == 4); | 139 SkASSERT(sizeof(float) == 4); |
165 for (int i = 0; i < arrayCount; ++i) { | 140 for (int i = 0; i < arrayCount; ++i) { |
166 const float* curVec = &v[3 * i]; | 141 const float* curVec = &v[3 * i]; |
167 memcpy(buffer, curVec, 3 * sizeof(float)); | 142 memcpy(buffer, curVec, 3 * sizeof(float)); |
168 buffer = static_cast<char*>(buffer) + 4*sizeof(float); | 143 buffer = static_cast<char*>(buffer) + 4*sizeof(float); |
169 } | 144 } |
170 } | 145 } |
171 | 146 |
172 void GrVkProgramDataManager::set4f(UniformHandle u, float v0, float v1, float v2
, float v3) const { | 147 void GrVkProgramDataManager::set4f(UniformHandle u, float v0, float v1, float v2
, float v3) const { |
173 const Uniform& uni = fUniforms[u.toIndex()]; | 148 const Uniform& uni = fUniforms[u.toIndex()]; |
174 SkASSERT(uni.fType == kVec4f_GrSLType); | 149 SkASSERT(uni.fType == kVec4f_GrSLType); |
175 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 150 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
176 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 151 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
177 void* buffer; | 152 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
178 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
179 buffer = fVertexUniformData.get(); | |
180 } else { | |
181 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
182 buffer = fFragmentUniformData.get(); | |
183 } | |
184 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
185 SkASSERT(sizeof(float) == 4); | 153 SkASSERT(sizeof(float) == 4); |
186 float v[4] = { v0, v1, v2, v3 }; | 154 float v[4] = { v0, v1, v2, v3 }; |
187 memcpy(buffer, v, 4 * sizeof(float)); | 155 memcpy(buffer, v, 4 * sizeof(float)); |
188 } | 156 } |
189 | 157 |
190 void GrVkProgramDataManager::set4fv(UniformHandle u, | 158 void GrVkProgramDataManager::set4fv(UniformHandle u, |
191 int arrayCount, | 159 int arrayCount, |
192 const float v[]) const { | 160 const float v[]) const { |
193 const Uniform& uni = fUniforms[u.toIndex()]; | 161 const Uniform& uni = fUniforms[u.toIndex()]; |
194 SkASSERT(uni.fType == kVec4f_GrSLType); | 162 SkASSERT(uni.fType == kVec4f_GrSLType); |
195 SkASSERT(arrayCount > 0); | 163 SkASSERT(arrayCount > 0); |
196 SkASSERT(arrayCount <= uni.fArrayCount || | 164 SkASSERT(arrayCount <= uni.fArrayCount || |
197 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 165 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
198 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 166 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
199 | 167 |
200 void* buffer; | 168 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
201 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | |
202 buffer = fVertexUniformData.get(); | |
203 } else { | |
204 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | |
205 buffer = fFragmentUniformData.get(); | |
206 } | |
207 buffer = static_cast<char*>(buffer) + uni.fOffset; | |
208 SkASSERT(sizeof(float) == 4); | 169 SkASSERT(sizeof(float) == 4); |
209 memcpy(buffer, v, arrayCount * 4 * sizeof(float)); | 170 memcpy(buffer, v, arrayCount * 4 * sizeof(float)); |
210 } | 171 } |
211 | 172 |
212 void GrVkProgramDataManager::setMatrix2f(UniformHandle u, const float matrix[])
const { | 173 void GrVkProgramDataManager::setMatrix2f(UniformHandle u, const float matrix[])
const { |
213 this->setMatrices<2>(u, 1, matrix); | 174 this->setMatrices<2>(u, 1, matrix); |
214 } | 175 } |
215 | 176 |
216 void GrVkProgramDataManager::setMatrix2fv(UniformHandle u, int arrayCount, const
float m[]) const { | 177 void GrVkProgramDataManager::setMatrix2fv(UniformHandle u, int arrayCount, const
float m[]) const { |
217 this->setMatrices<2>(u, arrayCount, m); | 178 this->setMatrices<2>(u, arrayCount, m); |
(...skipping 11 matching lines...) Expand all Loading... |
229 this->setMatrices<4>(u, 1, matrix); | 190 this->setMatrices<4>(u, 1, matrix); |
230 } | 191 } |
231 | 192 |
232 void GrVkProgramDataManager::setMatrix4fv(UniformHandle u, int arrayCount, const
float m[]) const { | 193 void GrVkProgramDataManager::setMatrix4fv(UniformHandle u, int arrayCount, const
float m[]) const { |
233 this->setMatrices<4>(u, arrayCount, m); | 194 this->setMatrices<4>(u, arrayCount, m); |
234 } | 195 } |
235 | 196 |
236 template<int N> struct set_uniform_matrix; | 197 template<int N> struct set_uniform_matrix; |
237 | 198 |
238 template<int N> inline void GrVkProgramDataManager::setMatrices(UniformHandle u, | 199 template<int N> inline void GrVkProgramDataManager::setMatrices(UniformHandle u, |
239 int arrayCoun
t, | 200 int arrayCount, |
240 const float m
atrices[]) const { | 201 const float matr
ices[]) const { |
241 const Uniform& uni = fUniforms[u.toIndex()]; | 202 const Uniform& uni = fUniforms[u.toIndex()]; |
242 SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2)); | 203 SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2)); |
243 SkASSERT(arrayCount > 0); | 204 SkASSERT(arrayCount > 0); |
244 SkASSERT(arrayCount <= uni.fArrayCount || | 205 SkASSERT(arrayCount <= uni.fArrayCount || |
245 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 206 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
246 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | 207 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); |
247 | 208 |
248 void* buffer; | 209 void* buffer; |
249 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | 210 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { |
250 buffer = fVertexUniformData.get(); | 211 buffer = fVertexUniformData.get(); |
| 212 fVertexUniformsDirty = true; |
251 } else { | 213 } else { |
252 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | 214 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); |
253 buffer = fFragmentUniformData.get(); | 215 buffer = fFragmentUniformData.get(); |
| 216 fFragmentUniformsDirty = true; |
254 } | 217 } |
255 | 218 |
256 set_uniform_matrix<N>::set(buffer, uni.fOffset, arrayCount, matrices); | 219 set_uniform_matrix<N>::set(buffer, uni.fOffset, arrayCount, matrices); |
257 } | 220 } |
258 | 221 |
259 template<int N> struct set_uniform_matrix { | 222 template<int N> struct set_uniform_matrix { |
260 inline static void set(void* buffer, int uniformOffset, int count, const flo
at matrices[]) { | 223 inline static void set(void* buffer, int uniformOffset, int count, const flo
at matrices[]) { |
261 GR_STATIC_ASSERT(sizeof(float) == 4); | 224 GR_STATIC_ASSERT(sizeof(float) == 4); |
262 buffer = static_cast<char*>(buffer) + uniformOffset; | 225 buffer = static_cast<char*>(buffer) + uniformOffset; |
263 for (int i = 0; i < count; ++i) { | 226 for (int i = 0; i < count; ++i) { |
(...skipping 12 matching lines...) Expand all Loading... |
276 inline static void set(void* buffer, int uniformOffset, int count, const flo
at matrices[]) { | 239 inline static void set(void* buffer, int uniformOffset, int count, const flo
at matrices[]) { |
277 GR_STATIC_ASSERT(sizeof(float) == 4); | 240 GR_STATIC_ASSERT(sizeof(float) == 4); |
278 buffer = static_cast<char*>(buffer) + uniformOffset; | 241 buffer = static_cast<char*>(buffer) + uniformOffset; |
279 memcpy(buffer, matrices, count * 16 * sizeof(float)); | 242 memcpy(buffer, matrices, count * 16 * sizeof(float)); |
280 } | 243 } |
281 }; | 244 }; |
282 | 245 |
283 void GrVkProgramDataManager::uploadUniformBuffers(const GrVkGpu* gpu, | 246 void GrVkProgramDataManager::uploadUniformBuffers(const GrVkGpu* gpu, |
284 GrVkUniformBuffer* vertexBuffe
r, | 247 GrVkUniformBuffer* vertexBuffe
r, |
285 GrVkUniformBuffer* fragmentBuf
fer) const { | 248 GrVkUniformBuffer* fragmentBuf
fer) const { |
286 if (vertexBuffer) { | 249 if (vertexBuffer && fVertexUniformsDirty) { |
287 vertexBuffer->addMemoryBarrier(gpu, | 250 vertexBuffer->addMemoryBarrier(gpu, |
288 VK_ACCESS_UNIFORM_READ_BIT, | 251 VK_ACCESS_UNIFORM_READ_BIT, |
289 VK_ACCESS_HOST_WRITE_BIT, | 252 VK_ACCESS_HOST_WRITE_BIT, |
290 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, | 253 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, |
291 VK_PIPELINE_STAGE_HOST_BIT, | 254 VK_PIPELINE_STAGE_HOST_BIT, |
292 false); | 255 false); |
293 SkAssertResult(vertexBuffer->updateData(gpu, fVertexUniformData.get(), f
VertexUniformSize)); | 256 SkAssertResult(vertexBuffer->updateData(gpu, fVertexUniformData.get(), f
VertexUniformSize)); |
| 257 fVertexUniformsDirty = false; |
294 } | 258 } |
295 | 259 |
296 if (fragmentBuffer) { | 260 if (fragmentBuffer && fFragmentUniformsDirty) { |
297 fragmentBuffer->addMemoryBarrier(gpu, | 261 fragmentBuffer->addMemoryBarrier(gpu, |
298 VK_ACCESS_UNIFORM_READ_BIT, | 262 VK_ACCESS_UNIFORM_READ_BIT, |
299 VK_ACCESS_HOST_WRITE_BIT, | 263 VK_ACCESS_HOST_WRITE_BIT, |
300 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, | 264 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, |
301 VK_PIPELINE_STAGE_HOST_BIT, | 265 VK_PIPELINE_STAGE_HOST_BIT, |
302 false); | 266 false); |
303 SkAssertResult(fragmentBuffer->updateData(gpu, fFragmentUniformData.get(
), | 267 SkAssertResult(fragmentBuffer->updateData(gpu, fFragmentUniformData.get(
), |
304 fFragmentUniformSize)); | 268 fFragmentUniformSize)); |
| 269 fFragmentUniformsDirty = false; |
305 } | 270 } |
306 } | 271 } |
307 | 272 |
OLD | NEW |