1 /*
2 * Copyright 2012 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
8 #include "SkMatrix.h"
9 #include "gl/GrGLProgramDataManager.h"
10 #include "gl/GrGLGpu.h"
11 #include "glsl/GrGLSLUniformHandler.h"
12
13 #define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, COUNT) \
14 SkASSERT((COUNT) <= (UNI).fArrayCount || \
15 (1 == (COUNT) && GrGLSLShaderVar::kNonArray == (UNI).fArrayCount))
16
GrGLProgramDataManager(GrGLGpu * gpu,GrGLuint programID,const UniformInfoArray & uniforms,const VaryingInfoArray & pathProcVaryings)17 GrGLProgramDataManager::GrGLProgramDataManager(GrGLGpu* gpu, GrGLuint programID,
18 const UniformInfoArray& uniforms,
19 const VaryingInfoArray& pathProcVaryings)
20 : fGpu(gpu)
21 , fProgramID(programID) {
22 int count = uniforms.count();
23 fUniforms.push_back_n(count);
24 for (int i = 0; i < count; i++) {
25 Uniform& uniform = fUniforms[i];
26 const UniformInfo& builderUniform = uniforms[i];
27 SkASSERT(GrGLSLShaderVar::kNonArray == builderUniform.fVariable.getArrayCount() ||
28 builderUniform.fVariable.getArrayCount() > 0);
29 SkDEBUGCODE(
30 uniform.fArrayCount = builderUniform.fVariable.getArrayCount();
31 uniform.fType = builderUniform.fVariable.getType();
32 );
33 // TODO: Move the Xoom uniform array in both FS and VS bug workaround here.
34
35 if (kVertex_GrShaderFlag & builderUniform.fVisibility) {
36 uniform.fVSLocation = builderUniform.fLocation;
37 } else {
38 uniform.fVSLocation = kUnusedUniform;
39 }
40 if (kFragment_GrShaderFlag & builderUniform.fVisibility) {
41 uniform.fFSLocation = builderUniform.fLocation;
42 } else {
43 uniform.fFSLocation = kUnusedUniform;
44 }
45 }
46
47 // NVPR programs have separable varyings
48 count = pathProcVaryings.count();
49 fPathProcVaryings.push_back_n(count);
50 for (int i = 0; i < count; i++) {
51 SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
52 PathProcVarying& pathProcVarying = fPathProcVaryings[i];
53 const VaryingInfo& builderPathProcVarying = pathProcVaryings[i];
54 SkASSERT(GrGLSLShaderVar::kNonArray == builderPathProcVarying.fVariable.getArrayCount() ||
55 builderPathProcVarying.fVariable.getArrayCount() > 0);
56 SkDEBUGCODE(
57 pathProcVarying.fArrayCount = builderPathProcVarying.fVariable.getArrayCount();
58 pathProcVarying.fType = builderPathProcVarying.fVariable.getType();
59 );
60 pathProcVarying.fLocation = builderPathProcVarying.fLocation;
61 }
62 }
63
setSamplers(const SkTArray<GrGLSampler> & samplers) const64 void GrGLProgramDataManager::setSamplers(const SkTArray<GrGLSampler>& samplers) const {
65 for (int i = 0; i < samplers.count(); ++i) {
66 GrGLint vsLocation;
67 GrGLint fsLocation;
68 const GrGLSampler& sampler = samplers[i];
69 if (kVertex_GrShaderFlag & sampler.visibility()) {
70 vsLocation = sampler.location();
71 } else {
72 vsLocation = kUnusedUniform;
73 }
74 if (kFragment_GrShaderFlag & sampler.visibility()) {
75 fsLocation = sampler.location();
76 } else {
77 fsLocation = kUnusedUniform;
78 }
79 // FIXME: We still insert a single sampler uniform for every stage. If the shader does not
80 // reference the sampler then the compiler may have optimized it out. Uncomment this assert
81 // once stages insert their own samplers.
82 // this->printUnused(uni);
83 if (kUnusedUniform != fsLocation) {
84 GR_GL_CALL(fGpu->glInterface(), Uniform1i(fsLocation, i));
85 }
86 if (kUnusedUniform != vsLocation && vsLocation != fsLocation) {
87 GR_GL_CALL(fGpu->glInterface(), Uniform1i(vsLocation, i));
88 }
89 }
90 }
91
set1i(UniformHandle u,int32_t i) const92 void GrGLProgramDataManager::set1i(UniformHandle u, int32_t i) const {
93 const Uniform& uni = fUniforms[u.toIndex()];
94 SkASSERT(uni.fType == kInt_GrSLType);
95 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
96 SkDEBUGCODE(this->printUnused(uni));
97 if (kUnusedUniform != uni.fFSLocation) {
98 GR_GL_CALL(fGpu->glInterface(), Uniform1i(uni.fFSLocation, i));
99 }
100 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
101 GR_GL_CALL(fGpu->glInterface(), Uniform1i(uni.fVSLocation, i));
102 }
103 }
104
set1iv(UniformHandle u,int arrayCount,const int v[]) const105 void GrGLProgramDataManager::set1iv(UniformHandle u,
106 int arrayCount,
107 const int v[]) const {
108 const Uniform& uni = fUniforms[u.toIndex()];
109 SkASSERT(uni.fType == kInt_GrSLType);
110 SkASSERT(arrayCount > 0);
111 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
112 if (kUnusedUniform != uni.fFSLocation) {
113 GR_GL_CALL(fGpu->glInterface(), Uniform1iv(uni.fFSLocation, arrayCount, v));
114 }
115 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
116 GR_GL_CALL(fGpu->glInterface(), Uniform1iv(uni.fVSLocation, arrayCount, v));
117 }
118 }
119
set1f(UniformHandle u,float v0) const120 void GrGLProgramDataManager::set1f(UniformHandle u, float v0) const {
121 const Uniform& uni = fUniforms[u.toIndex()];
122 SkASSERT(uni.fType == kFloat_GrSLType);
123 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
124 SkDEBUGCODE(this->printUnused(uni);)
125 if (kUnusedUniform != uni.fFSLocation) {
126 GR_GL_CALL(fGpu->glInterface(), Uniform1f(uni.fFSLocation, v0));
127 }
128 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
129 GR_GL_CALL(fGpu->glInterface(), Uniform1f(uni.fVSLocation, v0));
130 }
131 }
132
set1fv(UniformHandle u,int arrayCount,const float v[]) const133 void GrGLProgramDataManager::set1fv(UniformHandle u,
134 int arrayCount,
135 const float v[]) const {
136 const Uniform& uni = fUniforms[u.toIndex()];
137 SkASSERT(uni.fType == kFloat_GrSLType);
138 SkASSERT(arrayCount > 0);
139 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
140 // This assert fires in some instances of the two-pt gradient for its VSParams.
141 // Once the uniform manager is responsible for inserting the duplicate uniform
142 // arrays in VS and FS driver bug workaround, this can be enabled.
143 // this->printUni(uni);
144 if (kUnusedUniform != uni.fFSLocation) {
145 GR_GL_CALL(fGpu->glInterface(), Uniform1fv(uni.fFSLocation, arrayCount, v));
146 }
147 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
148 GR_GL_CALL(fGpu->glInterface(), Uniform1fv(uni.fVSLocation, arrayCount, v));
149 }
150 }
151
set2f(UniformHandle u,float v0,float v1) const152 void GrGLProgramDataManager::set2f(UniformHandle u, float v0, float v1) const {
153 const Uniform& uni = fUniforms[u.toIndex()];
154 SkASSERT(uni.fType == kVec2f_GrSLType);
155 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
156 SkDEBUGCODE(this->printUnused(uni);)
157 if (kUnusedUniform != uni.fFSLocation) {
158 GR_GL_CALL(fGpu->glInterface(), Uniform2f(uni.fFSLocation, v0, v1));
159 }
160 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
161 GR_GL_CALL(fGpu->glInterface(), Uniform2f(uni.fVSLocation, v0, v1));
162 }
163 }
164
set2fv(UniformHandle u,int arrayCount,const float v[]) const165 void GrGLProgramDataManager::set2fv(UniformHandle u,
166 int arrayCount,
167 const float v[]) const {
168 const Uniform& uni = fUniforms[u.toIndex()];
169 SkASSERT(uni.fType == kVec2f_GrSLType);
170 SkASSERT(arrayCount > 0);
171 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
172 SkDEBUGCODE(this->printUnused(uni);)
173 if (kUnusedUniform != uni.fFSLocation) {
174 GR_GL_CALL(fGpu->glInterface(), Uniform2fv(uni.fFSLocation, arrayCount, v));
175 }
176 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
177 GR_GL_CALL(fGpu->glInterface(), Uniform2fv(uni.fVSLocation, arrayCount, v));
178 }
179 }
180
set3f(UniformHandle u,float v0,float v1,float v2) const181 void GrGLProgramDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
182 const Uniform& uni = fUniforms[u.toIndex()];
183 SkASSERT(uni.fType == kVec3f_GrSLType);
184 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
185 SkDEBUGCODE(this->printUnused(uni);)
186 if (kUnusedUniform != uni.fFSLocation) {
187 GR_GL_CALL(fGpu->glInterface(), Uniform3f(uni.fFSLocation, v0, v1, v2));
188 }
189 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
190 GR_GL_CALL(fGpu->glInterface(), Uniform3f(uni.fVSLocation, v0, v1, v2));
191 }
192 }
193
set3fv(UniformHandle u,int arrayCount,const float v[]) const194 void GrGLProgramDataManager::set3fv(UniformHandle u,
195 int arrayCount,
196 const float v[]) const {
197 const Uniform& uni = fUniforms[u.toIndex()];
198 SkASSERT(uni.fType == kVec3f_GrSLType);
199 SkASSERT(arrayCount > 0);
200 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
201 SkDEBUGCODE(this->printUnused(uni);)
202 if (kUnusedUniform != uni.fFSLocation) {
203 GR_GL_CALL(fGpu->glInterface(), Uniform3fv(uni.fFSLocation, arrayCount, v));
204 }
205 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
206 GR_GL_CALL(fGpu->glInterface(), Uniform3fv(uni.fVSLocation, arrayCount, v));
207 }
208 }
209
set4f(UniformHandle u,float v0,float v1,float v2,float v3) const210 void GrGLProgramDataManager::set4f(UniformHandle u,
211 float v0,
212 float v1,
213 float v2,
214 float v3) const {
215 const Uniform& uni = fUniforms[u.toIndex()];
216 SkASSERT(uni.fType == kVec4f_GrSLType);
217 SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
218 SkDEBUGCODE(this->printUnused(uni);)
219 if (kUnusedUniform != uni.fFSLocation) {
220 GR_GL_CALL(fGpu->glInterface(), Uniform4f(uni.fFSLocation, v0, v1, v2, v3));
221 }
222 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
223 GR_GL_CALL(fGpu->glInterface(), Uniform4f(uni.fVSLocation, v0, v1, v2, v3));
224 }
225 }
226
set4fv(UniformHandle u,int arrayCount,const float v[]) const227 void GrGLProgramDataManager::set4fv(UniformHandle u,
228 int arrayCount,
229 const float v[]) const {
230 const Uniform& uni = fUniforms[u.toIndex()];
231 SkASSERT(uni.fType == kVec4f_GrSLType);
232 SkASSERT(arrayCount > 0);
233 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
234 SkDEBUGCODE(this->printUnused(uni);)
235 if (kUnusedUniform != uni.fFSLocation) {
236 GR_GL_CALL(fGpu->glInterface(), Uniform4fv(uni.fFSLocation, arrayCount, v));
237 }
238 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
239 GR_GL_CALL(fGpu->glInterface(), Uniform4fv(uni.fVSLocation, arrayCount, v));
240 }
241 }
242
setMatrix2f(UniformHandle u,const float matrix[]) const243 void GrGLProgramDataManager::setMatrix2f(UniformHandle u, const float matrix[]) const {
244 this->setMatrices<2>(u, 1, matrix);
245 }
246
setMatrix3f(UniformHandle u,const float matrix[]) const247 void GrGLProgramDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const {
248 this->setMatrices<3>(u, 1, matrix);
249 }
250
setMatrix4f(UniformHandle u,const float matrix[]) const251 void GrGLProgramDataManager::setMatrix4f(UniformHandle u, const float matrix[]) const {
252 this->setMatrices<4>(u, 1, matrix);
253 }
254
setMatrix2fv(UniformHandle u,int arrayCount,const float m[]) const255 void GrGLProgramDataManager::setMatrix2fv(UniformHandle u, int arrayCount, const float m[]) const {
256 this->setMatrices<2>(u, arrayCount, m);
257 }
258
setMatrix3fv(UniformHandle u,int arrayCount,const float m[]) const259 void GrGLProgramDataManager::setMatrix3fv(UniformHandle u, int arrayCount, const float m[]) const {
260 this->setMatrices<3>(u, arrayCount, m);
261 }
262
setMatrix4fv(UniformHandle u,int arrayCount,const float m[]) const263 void GrGLProgramDataManager::setMatrix4fv(UniformHandle u, int arrayCount, const float m[]) const {
264 this->setMatrices<4>(u, arrayCount, m);
265 }
266
267 template<int N> struct set_uniform_matrix;
268
setMatrices(UniformHandle u,int arrayCount,const float matrices[]) const269 template<int N> inline void GrGLProgramDataManager::setMatrices(UniformHandle u,
270 int arrayCount,
271 const float matrices[]) const {
272 const Uniform& uni = fUniforms[u.toIndex()];
273 SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2));
274 SkASSERT(arrayCount > 0);
275 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
276 SkDEBUGCODE(this->printUnused(uni);)
277 if (kUnusedUniform != uni.fFSLocation) {
278 set_uniform_matrix<N>::set(fGpu->glInterface(), uni.fFSLocation, arrayCount, matrices);
279 }
280 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
281 set_uniform_matrix<N>::set(fGpu->glInterface(), uni.fVSLocation, arrayCount, matrices);
282 }
283 }
284
285 template<> struct set_uniform_matrix<2> {
setset_uniform_matrix286 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
287 GR_GL_CALL(gli, UniformMatrix2fv(loc, cnt, false, m));
288 }
289 };
290
291 template<> struct set_uniform_matrix<3> {
setset_uniform_matrix292 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
293 GR_GL_CALL(gli, UniformMatrix3fv(loc, cnt, false, m));
294 }
295 };
296
297 template<> struct set_uniform_matrix<4> {
setset_uniform_matrix298 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
299 GR_GL_CALL(gli, UniformMatrix4fv(loc, cnt, false, m));
300 }
301 };
302
setPathFragmentInputTransform(VaryingHandle u,int components,const SkMatrix & matrix) const303 void GrGLProgramDataManager::setPathFragmentInputTransform(VaryingHandle u,
304 int components,
305 const SkMatrix& matrix) const {
306 SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
307 const PathProcVarying& fragmentInput = fPathProcVaryings[u.toIndex()];
308
309 SkASSERT((components == 2 && fragmentInput.fType == kVec2f_GrSLType) ||
310 (components == 3 && fragmentInput.fType == kVec3f_GrSLType));
311
312 fGpu->glPathRendering()->setProgramPathFragmentInputTransform(fProgramID,
313 fragmentInput.fLocation,
314 GR_GL_OBJECT_LINEAR,
315 components,
316 matrix);
317 }
318
319 #ifdef SK_DEBUG
printUnused(const Uniform & uni) const320 void GrGLProgramDataManager::printUnused(const Uniform& uni) const {
321 if (kUnusedUniform == uni.fFSLocation && kUnusedUniform == uni.fVSLocation) {
322 GrCapsDebugf(fGpu->caps(), "Unused uniform in shader\n");
323 }
324 }
325 #endif
326