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 "GrVkPipelineStateDataManager.h" | 8 #include "GrVkPipelineStateDataManager.h" |
9 | 9 |
10 #include "GrVkGpu.h" | 10 #include "GrVkGpu.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 // owned by other objects will still match up here. | 25 // owned by other objects will still match up here. |
26 for (int i = 0; i < count; i++) { | 26 for (int i = 0; i < count; i++) { |
27 Uniform& uniform = fUniforms[i]; | 27 Uniform& uniform = fUniforms[i]; |
28 const GrVkUniformHandler::UniformInfo uniformInfo = uniforms[i]; | 28 const GrVkUniformHandler::UniformInfo uniformInfo = uniforms[i]; |
29 SkASSERT(GrGLSLShaderVar::kNonArray == uniformInfo.fVariable.getArrayCou
nt() || | 29 SkASSERT(GrGLSLShaderVar::kNonArray == uniformInfo.fVariable.getArrayCou
nt() || |
30 uniformInfo.fVariable.getArrayCount() > 0); | 30 uniformInfo.fVariable.getArrayCount() > 0); |
31 SkDEBUGCODE( | 31 SkDEBUGCODE( |
32 uniform.fArrayCount = uniformInfo.fVariable.getArrayCount(); | 32 uniform.fArrayCount = uniformInfo.fVariable.getArrayCount(); |
33 uniform.fType = uniformInfo.fVariable.getType(); | 33 uniform.fType = uniformInfo.fVariable.getType(); |
34 ); | 34 ); |
35 uniform.fBinding = uniformInfo.fBinding; | 35 uniform.fBinding = |
| 36 (kVertex_GrShaderFlag == uniformInfo.fVisibility) ? GrVkUniformHandl
er::kVertexBinding |
| 37 : GrVkUniformHandl
er::kFragBinding; |
36 uniform.fOffset = uniformInfo.fUBOffset; | 38 uniform.fOffset = uniformInfo.fUBOffset; |
37 SkDEBUGCODE( | |
38 uniform.fSetNumber = uniformInfo.fSetNumber; | |
39 ); | |
40 } | 39 } |
41 } | 40 } |
42 | 41 |
43 void* GrVkPipelineStateDataManager::getBufferPtrAndMarkDirty(const Uniform& uni)
const { | 42 void* GrVkPipelineStateDataManager::getBufferPtrAndMarkDirty(const Uniform& uni)
const { |
44 void* buffer; | 43 void* buffer; |
45 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | 44 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { |
46 buffer = fVertexUniformData.get(); | 45 buffer = fVertexUniformData.get(); |
47 fVertexUniformsDirty = true; | 46 fVertexUniformsDirty = true; |
48 } | 47 } |
49 else { | 48 else { |
50 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | 49 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); |
51 buffer = fFragmentUniformData.get(); | 50 buffer = fFragmentUniformData.get(); |
52 fFragmentUniformsDirty = true; | 51 fFragmentUniformsDirty = true; |
53 } | 52 } |
54 buffer = static_cast<char*>(buffer)+uni.fOffset; | 53 buffer = static_cast<char*>(buffer)+uni.fOffset; |
55 return buffer; | 54 return buffer; |
56 } | 55 } |
57 | 56 |
58 void GrVkPipelineStateDataManager::set1f(UniformHandle u, float v0) const { | 57 void GrVkPipelineStateDataManager::set1f(UniformHandle u, float v0) const { |
59 const Uniform& uni = fUniforms[u.toIndex()]; | 58 const Uniform& uni = fUniforms[u.toIndex()]; |
60 SkASSERT(uni.fType == kFloat_GrSLType); | 59 SkASSERT(uni.fType == kFloat_GrSLType); |
61 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 60 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
62 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
63 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 61 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
64 SkASSERT(sizeof(float) == 4); | 62 SkASSERT(sizeof(float) == 4); |
65 memcpy(buffer, &v0, sizeof(float)); | 63 memcpy(buffer, &v0, sizeof(float)); |
66 } | 64 } |
67 | 65 |
68 void GrVkPipelineStateDataManager::set1fv(UniformHandle u, | 66 void GrVkPipelineStateDataManager::set1fv(UniformHandle u, |
69 int arrayCount, | 67 int arrayCount, |
70 const float v[]) const { | 68 const float v[]) const { |
71 const Uniform& uni = fUniforms[u.toIndex()]; | 69 const Uniform& uni = fUniforms[u.toIndex()]; |
72 SkASSERT(uni.fType == kFloat_GrSLType); | 70 SkASSERT(uni.fType == kFloat_GrSLType); |
73 SkASSERT(arrayCount > 0); | 71 SkASSERT(arrayCount > 0); |
74 SkASSERT(arrayCount <= uni.fArrayCount || | 72 SkASSERT(arrayCount <= uni.fArrayCount || |
75 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 73 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
76 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
77 | 74 |
78 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 75 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
79 SkASSERT(sizeof(float) == 4); | 76 SkASSERT(sizeof(float) == 4); |
80 for (int i = 0; i < arrayCount; ++i) { | 77 for (int i = 0; i < arrayCount; ++i) { |
81 const float* curVec = &v[i]; | 78 const float* curVec = &v[i]; |
82 memcpy(buffer, curVec, sizeof(float)); | 79 memcpy(buffer, curVec, sizeof(float)); |
83 buffer = static_cast<char*>(buffer) + 4*sizeof(float); | 80 buffer = static_cast<char*>(buffer) + 4*sizeof(float); |
84 } | 81 } |
85 } | 82 } |
86 | 83 |
87 void GrVkPipelineStateDataManager::set2f(UniformHandle u, float v0, float v1) co
nst { | 84 void GrVkPipelineStateDataManager::set2f(UniformHandle u, float v0, float v1) co
nst { |
88 const Uniform& uni = fUniforms[u.toIndex()]; | 85 const Uniform& uni = fUniforms[u.toIndex()]; |
89 SkASSERT(uni.fType == kVec2f_GrSLType); | 86 SkASSERT(uni.fType == kVec2f_GrSLType); |
90 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 87 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
91 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
92 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 88 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
93 SkASSERT(sizeof(float) == 4); | 89 SkASSERT(sizeof(float) == 4); |
94 float v[2] = { v0, v1 }; | 90 float v[2] = { v0, v1 }; |
95 memcpy(buffer, v, 2 * sizeof(float)); | 91 memcpy(buffer, v, 2 * sizeof(float)); |
96 } | 92 } |
97 | 93 |
98 void GrVkPipelineStateDataManager::set2fv(UniformHandle u, | 94 void GrVkPipelineStateDataManager::set2fv(UniformHandle u, |
99 int arrayCount, | 95 int arrayCount, |
100 const float v[]) const { | 96 const float v[]) const { |
101 const Uniform& uni = fUniforms[u.toIndex()]; | 97 const Uniform& uni = fUniforms[u.toIndex()]; |
102 SkASSERT(uni.fType == kVec2f_GrSLType); | 98 SkASSERT(uni.fType == kVec2f_GrSLType); |
103 SkASSERT(arrayCount > 0); | 99 SkASSERT(arrayCount > 0); |
104 SkASSERT(arrayCount <= uni.fArrayCount || | 100 SkASSERT(arrayCount <= uni.fArrayCount || |
105 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 101 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
106 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
107 | 102 |
108 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 103 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
109 SkASSERT(sizeof(float) == 4); | 104 SkASSERT(sizeof(float) == 4); |
110 for (int i = 0; i < arrayCount; ++i) { | 105 for (int i = 0; i < arrayCount; ++i) { |
111 const float* curVec = &v[2 * i]; | 106 const float* curVec = &v[2 * i]; |
112 memcpy(buffer, curVec, 2 * sizeof(float)); | 107 memcpy(buffer, curVec, 2 * sizeof(float)); |
113 buffer = static_cast<char*>(buffer) + 4*sizeof(float); | 108 buffer = static_cast<char*>(buffer) + 4*sizeof(float); |
114 } | 109 } |
115 } | 110 } |
116 | 111 |
117 void GrVkPipelineStateDataManager::set3f(UniformHandle u, float v0, float v1, fl
oat v2) const { | 112 void GrVkPipelineStateDataManager::set3f(UniformHandle u, float v0, float v1, fl
oat v2) const { |
118 const Uniform& uni = fUniforms[u.toIndex()]; | 113 const Uniform& uni = fUniforms[u.toIndex()]; |
119 SkASSERT(uni.fType == kVec3f_GrSLType); | 114 SkASSERT(uni.fType == kVec3f_GrSLType); |
120 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 115 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
121 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
122 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 116 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
123 SkASSERT(sizeof(float) == 4); | 117 SkASSERT(sizeof(float) == 4); |
124 float v[3] = { v0, v1, v2 }; | 118 float v[3] = { v0, v1, v2 }; |
125 memcpy(buffer, v, 3 * sizeof(float)); | 119 memcpy(buffer, v, 3 * sizeof(float)); |
126 } | 120 } |
127 | 121 |
128 void GrVkPipelineStateDataManager::set3fv(UniformHandle u, | 122 void GrVkPipelineStateDataManager::set3fv(UniformHandle u, |
129 int arrayCount, | 123 int arrayCount, |
130 const float v[]) const { | 124 const float v[]) const { |
131 const Uniform& uni = fUniforms[u.toIndex()]; | 125 const Uniform& uni = fUniforms[u.toIndex()]; |
132 SkASSERT(uni.fType == kVec3f_GrSLType); | 126 SkASSERT(uni.fType == kVec3f_GrSLType); |
133 SkASSERT(arrayCount > 0); | 127 SkASSERT(arrayCount > 0); |
134 SkASSERT(arrayCount <= uni.fArrayCount || | 128 SkASSERT(arrayCount <= uni.fArrayCount || |
135 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 129 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
136 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
137 | 130 |
138 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 131 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
139 SkASSERT(sizeof(float) == 4); | 132 SkASSERT(sizeof(float) == 4); |
140 for (int i = 0; i < arrayCount; ++i) { | 133 for (int i = 0; i < arrayCount; ++i) { |
141 const float* curVec = &v[3 * i]; | 134 const float* curVec = &v[3 * i]; |
142 memcpy(buffer, curVec, 3 * sizeof(float)); | 135 memcpy(buffer, curVec, 3 * sizeof(float)); |
143 buffer = static_cast<char*>(buffer) + 4*sizeof(float); | 136 buffer = static_cast<char*>(buffer) + 4*sizeof(float); |
144 } | 137 } |
145 } | 138 } |
146 | 139 |
147 void GrVkPipelineStateDataManager::set4f(UniformHandle u, | 140 void GrVkPipelineStateDataManager::set4f(UniformHandle u, |
148 float v0, | 141 float v0, |
149 float v1, | 142 float v1, |
150 float v2, | 143 float v2, |
151 float v3) const { | 144 float v3) const { |
152 const Uniform& uni = fUniforms[u.toIndex()]; | 145 const Uniform& uni = fUniforms[u.toIndex()]; |
153 SkASSERT(uni.fType == kVec4f_GrSLType); | 146 SkASSERT(uni.fType == kVec4f_GrSLType); |
154 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); | 147 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); |
155 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
156 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 148 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
157 SkASSERT(sizeof(float) == 4); | 149 SkASSERT(sizeof(float) == 4); |
158 float v[4] = { v0, v1, v2, v3 }; | 150 float v[4] = { v0, v1, v2, v3 }; |
159 memcpy(buffer, v, 4 * sizeof(float)); | 151 memcpy(buffer, v, 4 * sizeof(float)); |
160 } | 152 } |
161 | 153 |
162 void GrVkPipelineStateDataManager::set4fv(UniformHandle u, | 154 void GrVkPipelineStateDataManager::set4fv(UniformHandle u, |
163 int arrayCount, | 155 int arrayCount, |
164 const float v[]) const { | 156 const float v[]) const { |
165 const Uniform& uni = fUniforms[u.toIndex()]; | 157 const Uniform& uni = fUniforms[u.toIndex()]; |
166 SkASSERT(uni.fType == kVec4f_GrSLType); | 158 SkASSERT(uni.fType == kVec4f_GrSLType); |
167 SkASSERT(arrayCount > 0); | 159 SkASSERT(arrayCount > 0); |
168 SkASSERT(arrayCount <= uni.fArrayCount || | 160 SkASSERT(arrayCount <= uni.fArrayCount || |
169 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 161 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
170 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
171 | 162 |
172 void* buffer = this->getBufferPtrAndMarkDirty(uni); | 163 void* buffer = this->getBufferPtrAndMarkDirty(uni); |
173 SkASSERT(sizeof(float) == 4); | 164 SkASSERT(sizeof(float) == 4); |
174 memcpy(buffer, v, arrayCount * 4 * sizeof(float)); | 165 memcpy(buffer, v, arrayCount * 4 * sizeof(float)); |
175 } | 166 } |
176 | 167 |
177 void GrVkPipelineStateDataManager::setMatrix2f(UniformHandle u, const float matr
ix[]) const { | 168 void GrVkPipelineStateDataManager::setMatrix2f(UniformHandle u, const float matr
ix[]) const { |
178 this->setMatrices<2>(u, 1, matrix); | 169 this->setMatrices<2>(u, 1, matrix); |
179 } | 170 } |
180 | 171 |
(...skipping 26 matching lines...) Expand all Loading... |
207 template<int N> struct set_uniform_matrix; | 198 template<int N> struct set_uniform_matrix; |
208 | 199 |
209 template<int N> inline void GrVkPipelineStateDataManager::setMatrices(UniformHan
dle u, | 200 template<int N> inline void GrVkPipelineStateDataManager::setMatrices(UniformHan
dle u, |
210 int arrayC
ount, | 201 int arrayC
ount, |
211 const float
matrices[]) const { | 202 const float
matrices[]) const { |
212 const Uniform& uni = fUniforms[u.toIndex()]; | 203 const Uniform& uni = fUniforms[u.toIndex()]; |
213 SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2)); | 204 SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2)); |
214 SkASSERT(arrayCount > 0); | 205 SkASSERT(arrayCount > 0); |
215 SkASSERT(arrayCount <= uni.fArrayCount || | 206 SkASSERT(arrayCount <= uni.fArrayCount || |
216 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; | 207 (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
; |
217 SkASSERT(GrVkUniformHandler::kUniformBufferDescSet == uni.fSetNumber); | |
218 | 208 |
219 void* buffer; | 209 void* buffer; |
220 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { | 210 if (GrVkUniformHandler::kVertexBinding == uni.fBinding) { |
221 buffer = fVertexUniformData.get(); | 211 buffer = fVertexUniformData.get(); |
222 fVertexUniformsDirty = true; | 212 fVertexUniformsDirty = true; |
223 } else { | 213 } else { |
224 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); | 214 SkASSERT(GrVkUniformHandler::kFragBinding == uni.fBinding); |
225 buffer = fFragmentUniformData.get(); | 215 buffer = fFragmentUniformData.get(); |
226 fFragmentUniformsDirty = true; | 216 fFragmentUniformsDirty = true; |
227 } | 217 } |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
275 VK_ACCESS_HOST_WRITE_BIT, | 265 VK_ACCESS_HOST_WRITE_BIT, |
276 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, | 266 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, |
277 VK_PIPELINE_STAGE_HOST_BIT, | 267 VK_PIPELINE_STAGE_HOST_BIT, |
278 false); | 268 false); |
279 SkAssertResult(fragmentBuffer->updateData(gpu, fFragmentUniformData.get(
), | 269 SkAssertResult(fragmentBuffer->updateData(gpu, fFragmentUniformData.get(
), |
280 fFragmentUniformSize, &updated
Buffer)); | 270 fFragmentUniformSize, &updated
Buffer)); |
281 fFragmentUniformsDirty = false; | 271 fFragmentUniformsDirty = false; |
282 } | 272 } |
283 return updatedBuffer; | 273 return updatedBuffer; |
284 } | 274 } |
OLD | NEW |