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