1
2 /*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10 #include "GrGLProgram.h"
11
12 #include "../GrAllocator.h"
13 #include "GrGLShaderVar.h"
14 #include "SkTrace.h"
15 #include "SkXfermode.h"
16
17 namespace {
18
19 enum {
20 /// Used to mark a StageUniLocation field that should be bound
21 /// to a uniform during getUniformLocationsAndInitCache().
22 kUseUniform = 2000
23 };
24
25 } // namespace
26
27 #define PRINT_SHADERS 0
28
29 typedef GrTAllocator<GrGLShaderVar> VarArray;
30
31 // number of each input/output type in a single allocation block
32 static const int gVarsPerBlock = 8;
33 // except FS outputs where we expect 2 at most.
34 static const int gMaxFSOutputs = 2;
35
36 struct ShaderCodeSegments {
ShaderCodeSegmentsShaderCodeSegments37 ShaderCodeSegments()
38 : fVSUnis(gVarsPerBlock)
39 , fVSAttrs(gVarsPerBlock)
40 , fVSOutputs(gVarsPerBlock)
41 , fGSInputs(gVarsPerBlock)
42 , fGSOutputs(gVarsPerBlock)
43 , fFSInputs(gVarsPerBlock)
44 , fFSUnis(gVarsPerBlock)
45 , fFSOutputs(gMaxFSOutputs)
46 , fUsesGS(false) {}
47 GrStringBuilder fHeader; // VS+FS, GLSL version, etc
48 VarArray fVSUnis;
49 VarArray fVSAttrs;
50 VarArray fVSOutputs;
51 VarArray fGSInputs;
52 VarArray fGSOutputs;
53 VarArray fFSInputs;
54 GrStringBuilder fGSHeader; // layout qualifiers specific to GS
55 VarArray fFSUnis;
56 VarArray fFSOutputs;
57 GrStringBuilder fFSFunctions;
58 GrStringBuilder fVSCode;
59 GrStringBuilder fGSCode;
60 GrStringBuilder fFSCode;
61
62 bool fUsesGS;
63 };
64
65 typedef GrGLProgram::ProgramDesc::StageDesc StageDesc;
66
67 #if GR_GL_ATTRIBUTE_MATRICES
68 #define VIEW_MATRIX_NAME "aViewM"
69 #else
70 #define VIEW_MATRIX_NAME "uViewM"
71 #endif
72
73 #define POS_ATTR_NAME "aPosition"
74 #define COL_ATTR_NAME "aColor"
75 #define COV_ATTR_NAME "aCoverage"
76 #define EDGE_ATTR_NAME "aEdge"
77 #define COL_UNI_NAME "uColor"
78 #define COV_UNI_NAME "uCoverage"
79 #define EDGES_UNI_NAME "uEdges"
80 #define COL_FILTER_UNI_NAME "uColorFilter"
81 #define COL_MATRIX_UNI_NAME "uColorMatrix"
82 #define COL_MATRIX_VEC_UNI_NAME "uColorMatrixVec"
83
84 namespace {
tex_attr_name(int coordIdx,GrStringBuilder * s)85 inline void tex_attr_name(int coordIdx, GrStringBuilder* s) {
86 *s = "aTexCoord";
87 s->appendS32(coordIdx);
88 }
89
float_vector_type(int count)90 inline GrGLShaderVar::Type float_vector_type(int count) {
91 GR_STATIC_ASSERT(GrGLShaderVar::kFloat_Type == 0);
92 GR_STATIC_ASSERT(GrGLShaderVar::kVec2f_Type == 1);
93 GR_STATIC_ASSERT(GrGLShaderVar::kVec3f_Type == 2);
94 GR_STATIC_ASSERT(GrGLShaderVar::kVec4f_Type == 3);
95 GrAssert(count > 0 && count <= 4);
96 return (GrGLShaderVar::Type)(count - 1);
97 }
98
float_vector_type_str(int count)99 inline const char* float_vector_type_str(int count) {
100 return GrGLShaderVar::TypeString(float_vector_type(count));
101 }
102
vector_homog_coord(int count)103 inline const char* vector_homog_coord(int count) {
104 static const char* HOMOGS[] = {"ERROR", "", ".y", ".z", ".w"};
105 GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(HOMOGS));
106 return HOMOGS[count];
107 }
108
vector_nonhomog_coords(int count)109 inline const char* vector_nonhomog_coords(int count) {
110 static const char* NONHOMOGS[] = {"ERROR", "", ".x", ".xy", ".xyz"};
111 GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(NONHOMOGS));
112 return NONHOMOGS[count];
113 }
114
vector_all_coords(int count)115 inline const char* vector_all_coords(int count) {
116 static const char* ALL[] = {"ERROR", "", ".xy", ".xyz", ".xyzw"};
117 GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(ALL));
118 return ALL[count];
119 }
120
all_ones_vec(int count)121 inline const char* all_ones_vec(int count) {
122 static const char* ONESVEC[] = {"ERROR", "1.0", "vec2(1,1)",
123 "vec3(1,1,1)", "vec4(1,1,1,1)"};
124 GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(ONESVEC));
125 return ONESVEC[count];
126 }
127
all_zeros_vec(int count)128 inline const char* all_zeros_vec(int count) {
129 static const char* ZEROSVEC[] = {"ERROR", "0.0", "vec2(0,0)",
130 "vec3(0,0,0)", "vec4(0,0,0,0)"};
131 GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(ZEROSVEC));
132 return ZEROSVEC[count];
133 }
134
declared_color_output_name()135 inline const char* declared_color_output_name() { return "fsColorOut"; }
dual_source_output_name()136 inline const char* dual_source_output_name() { return "dualSourceOut"; }
137
tex_matrix_name(int stage,GrStringBuilder * s)138 inline void tex_matrix_name(int stage, GrStringBuilder* s) {
139 #if GR_GL_ATTRIBUTE_MATRICES
140 *s = "aTexM";
141 #else
142 *s = "uTexM";
143 #endif
144 s->appendS32(stage);
145 }
146
normalized_texel_size_name(int stage,GrStringBuilder * s)147 inline void normalized_texel_size_name(int stage, GrStringBuilder* s) {
148 *s = "uTexelSize";
149 s->appendS32(stage);
150 }
151
sampler_name(int stage,GrStringBuilder * s)152 inline void sampler_name(int stage, GrStringBuilder* s) {
153 *s = "uSampler";
154 s->appendS32(stage);
155 }
156
radial2_param_name(int stage,GrStringBuilder * s)157 inline void radial2_param_name(int stage, GrStringBuilder* s) {
158 *s = "uRadial2Params";
159 s->appendS32(stage);
160 }
161
convolve_param_names(int stage,GrStringBuilder * k,GrStringBuilder * i)162 inline void convolve_param_names(int stage, GrStringBuilder* k, GrStringBuilder* i) {
163 *k = "uKernel";
164 k->appendS32(stage);
165 *i = "uImageIncrement";
166 i->appendS32(stage);
167 }
168
image_increment_param_name(int stage,GrStringBuilder * i)169 inline void image_increment_param_name(int stage, GrStringBuilder* i) {
170 *i = "uImageIncrement";
171 i->appendS32(stage);
172 }
173
tex_domain_name(int stage,GrStringBuilder * s)174 inline void tex_domain_name(int stage, GrStringBuilder* s) {
175 *s = "uTexDom";
176 s->appendS32(stage);
177 }
178 }
179
GrGLProgram()180 GrGLProgram::GrGLProgram() {
181 }
182
~GrGLProgram()183 GrGLProgram::~GrGLProgram() {
184 }
185
overrideBlend(GrBlendCoeff * srcCoeff,GrBlendCoeff * dstCoeff) const186 void GrGLProgram::overrideBlend(GrBlendCoeff* srcCoeff,
187 GrBlendCoeff* dstCoeff) const {
188 switch (fProgramDesc.fDualSrcOutput) {
189 case ProgramDesc::kNone_DualSrcOutput:
190 break;
191 // the prog will write a coverage value to the secondary
192 // output and the dst is blended by one minus that value.
193 case ProgramDesc::kCoverage_DualSrcOutput:
194 case ProgramDesc::kCoverageISA_DualSrcOutput:
195 case ProgramDesc::kCoverageISC_DualSrcOutput:
196 *dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_BlendCoeff;
197 break;
198 default:
199 GrCrash("Unexpected dual source blend output");
200 break;
201 }
202 }
203
204 // assigns modulation of two vars to an output var
205 // vars can be vec4s or floats (or one of each)
206 // result is always vec4
207 // if either var is "" then assign to the other var
208 // if both are "" then assign all ones
modulate_helper(const char * outputVar,const char * var0,const char * var1,GrStringBuilder * code)209 static inline void modulate_helper(const char* outputVar,
210 const char* var0,
211 const char* var1,
212 GrStringBuilder* code) {
213 GrAssert(NULL != outputVar);
214 GrAssert(NULL != var0);
215 GrAssert(NULL != var1);
216 GrAssert(NULL != code);
217
218 bool has0 = '\0' != *var0;
219 bool has1 = '\0' != *var1;
220
221 if (!has0 && !has1) {
222 code->appendf("\t%s = %s;\n", outputVar, all_ones_vec(4));
223 } else if (!has0) {
224 code->appendf("\t%s = vec4(%s);\n", outputVar, var1);
225 } else if (!has1) {
226 code->appendf("\t%s = vec4(%s);\n", outputVar, var0);
227 } else {
228 code->appendf("\t%s = vec4(%s * %s);\n", outputVar, var0, var1);
229 }
230 }
231
232 // assigns addition of two vars to an output var
233 // vars can be vec4s or floats (or one of each)
234 // result is always vec4
235 // if either var is "" then assign to the other var
236 // if both are "" then assign all zeros
add_helper(const char * outputVar,const char * var0,const char * var1,GrStringBuilder * code)237 static inline void add_helper(const char* outputVar,
238 const char* var0,
239 const char* var1,
240 GrStringBuilder* code) {
241 GrAssert(NULL != outputVar);
242 GrAssert(NULL != var0);
243 GrAssert(NULL != var1);
244 GrAssert(NULL != code);
245
246 bool has0 = '\0' != *var0;
247 bool has1 = '\0' != *var1;
248
249 if (!has0 && !has1) {
250 code->appendf("\t%s = %s;\n", outputVar, all_zeros_vec(4));
251 } else if (!has0) {
252 code->appendf("\t%s = vec4(%s);\n", outputVar, var1);
253 } else if (!has1) {
254 code->appendf("\t%s = vec4(%s);\n", outputVar, var0);
255 } else {
256 code->appendf("\t%s = vec4(%s + %s);\n", outputVar, var0, var1);
257 }
258 }
259
260 // given two blend coeffecients determine whether the src
261 // and/or dst computation can be omitted.
needBlendInputs(SkXfermode::Coeff srcCoeff,SkXfermode::Coeff dstCoeff,bool * needSrcValue,bool * needDstValue)262 static inline void needBlendInputs(SkXfermode::Coeff srcCoeff,
263 SkXfermode::Coeff dstCoeff,
264 bool* needSrcValue,
265 bool* needDstValue) {
266 if (SkXfermode::kZero_Coeff == srcCoeff) {
267 switch (dstCoeff) {
268 // these all read the src
269 case SkXfermode::kSC_Coeff:
270 case SkXfermode::kISC_Coeff:
271 case SkXfermode::kSA_Coeff:
272 case SkXfermode::kISA_Coeff:
273 *needSrcValue = true;
274 break;
275 default:
276 *needSrcValue = false;
277 break;
278 }
279 } else {
280 *needSrcValue = true;
281 }
282 if (SkXfermode::kZero_Coeff == dstCoeff) {
283 switch (srcCoeff) {
284 // these all read the dst
285 case SkXfermode::kDC_Coeff:
286 case SkXfermode::kIDC_Coeff:
287 case SkXfermode::kDA_Coeff:
288 case SkXfermode::kIDA_Coeff:
289 *needDstValue = true;
290 break;
291 default:
292 *needDstValue = false;
293 break;
294 }
295 } else {
296 *needDstValue = true;
297 }
298 }
299
300 /**
301 * Create a blend_coeff * value string to be used in shader code. Sets empty
302 * string if result is trivially zero.
303 */
blendTermString(GrStringBuilder * str,SkXfermode::Coeff coeff,const char * src,const char * dst,const char * value)304 static void blendTermString(GrStringBuilder* str, SkXfermode::Coeff coeff,
305 const char* src, const char* dst,
306 const char* value) {
307 switch (coeff) {
308 case SkXfermode::kZero_Coeff: /** 0 */
309 *str = "";
310 break;
311 case SkXfermode::kOne_Coeff: /** 1 */
312 *str = value;
313 break;
314 case SkXfermode::kSC_Coeff:
315 str->printf("(%s * %s)", src, value);
316 break;
317 case SkXfermode::kISC_Coeff:
318 str->printf("((%s - %s) * %s)", all_ones_vec(4), src, value);
319 break;
320 case SkXfermode::kDC_Coeff:
321 str->printf("(%s * %s)", dst, value);
322 break;
323 case SkXfermode::kIDC_Coeff:
324 str->printf("((%s - %s) * %s)", all_ones_vec(4), dst, value);
325 break;
326 case SkXfermode::kSA_Coeff: /** src alpha */
327 str->printf("(%s.a * %s)", src, value);
328 break;
329 case SkXfermode::kISA_Coeff: /** inverse src alpha (i.e. 1 - sa) */
330 str->printf("((1.0 - %s.a) * %s)", src, value);
331 break;
332 case SkXfermode::kDA_Coeff: /** dst alpha */
333 str->printf("(%s.a * %s)", dst, value);
334 break;
335 case SkXfermode::kIDA_Coeff: /** inverse dst alpha (i.e. 1 - da) */
336 str->printf("((1.0 - %s.a) * %s)", dst, value);
337 break;
338 default:
339 GrCrash("Unexpected xfer coeff.");
340 break;
341 }
342 }
343 /**
344 * Adds a line to the fragment shader code which modifies the color by
345 * the specified color filter.
346 */
addColorFilter(GrStringBuilder * fsCode,const char * outputVar,SkXfermode::Coeff uniformCoeff,SkXfermode::Coeff colorCoeff,const char * inColor)347 static void addColorFilter(GrStringBuilder* fsCode, const char * outputVar,
348 SkXfermode::Coeff uniformCoeff,
349 SkXfermode::Coeff colorCoeff,
350 const char* inColor) {
351 GrStringBuilder colorStr, constStr;
352 blendTermString(&colorStr, colorCoeff, COL_FILTER_UNI_NAME,
353 inColor, inColor);
354 blendTermString(&constStr, uniformCoeff, COL_FILTER_UNI_NAME,
355 inColor, COL_FILTER_UNI_NAME);
356
357 add_helper(outputVar, colorStr.c_str(), constStr.c_str(), fsCode);
358 }
359 /**
360 * Adds code to the fragment shader code which modifies the color by
361 * the specified color matrix.
362 */
addColorMatrix(GrStringBuilder * fsCode,const char * outputVar,const char * inColor)363 static void addColorMatrix(GrStringBuilder* fsCode, const char * outputVar,
364 const char* inColor) {
365 fsCode->appendf("\t%s = %s * vec4(%s.rgb / %s.a, %s.a) + %s;\n", outputVar, COL_MATRIX_UNI_NAME, inColor, inColor, inColor, COL_MATRIX_VEC_UNI_NAME);
366 fsCode->appendf("\t%s.rgb *= %s.a;\n", outputVar, outputVar);
367 }
368
369 namespace {
370
371 // Adds a var that is computed in the VS and read in FS.
372 // If there is a GS it will just pass it through.
append_varying(GrGLShaderVar::Type type,const char * name,ShaderCodeSegments * segments,const char ** vsOutName=NULL,const char ** fsInName=NULL)373 void append_varying(GrGLShaderVar::Type type,
374 const char* name,
375 ShaderCodeSegments* segments,
376 const char** vsOutName = NULL,
377 const char** fsInName = NULL) {
378 segments->fVSOutputs.push_back();
379 segments->fVSOutputs.back().setType(type);
380 segments->fVSOutputs.back().setTypeModifier(
381 GrGLShaderVar::kOut_TypeModifier);
382 segments->fVSOutputs.back().accessName()->printf("v%s", name);
383 if (vsOutName) {
384 *vsOutName = segments->fVSOutputs.back().getName().c_str();
385 }
386 // input to FS comes either from VS or GS
387 const GrStringBuilder* fsName;
388 if (segments->fUsesGS) {
389 // if we have a GS take each varying in as an array
390 // and output as non-array.
391 segments->fGSInputs.push_back();
392 segments->fGSInputs.back().setType(type);
393 segments->fGSInputs.back().setTypeModifier(
394 GrGLShaderVar::kIn_TypeModifier);
395 segments->fGSInputs.back().setUnsizedArray();
396 *segments->fGSInputs.back().accessName() =
397 segments->fVSOutputs.back().getName();
398 segments->fGSOutputs.push_back();
399 segments->fGSOutputs.back().setType(type);
400 segments->fGSOutputs.back().setTypeModifier(
401 GrGLShaderVar::kOut_TypeModifier);
402 segments->fGSOutputs.back().accessName()->printf("g%s", name);
403 fsName = segments->fGSOutputs.back().accessName();
404 } else {
405 fsName = segments->fVSOutputs.back().accessName();
406 }
407 segments->fFSInputs.push_back();
408 segments->fFSInputs.back().setType(type);
409 segments->fFSInputs.back().setTypeModifier(
410 GrGLShaderVar::kIn_TypeModifier);
411 segments->fFSInputs.back().setName(*fsName);
412 if (fsInName) {
413 *fsInName = fsName->c_str();
414 }
415 }
416
417 // version of above that adds a stage number to the
418 // the var name (for uniqueness)
append_varying(GrGLShaderVar::Type type,const char * name,int stageNum,ShaderCodeSegments * segments,const char ** vsOutName=NULL,const char ** fsInName=NULL)419 void append_varying(GrGLShaderVar::Type type,
420 const char* name,
421 int stageNum,
422 ShaderCodeSegments* segments,
423 const char** vsOutName = NULL,
424 const char** fsInName = NULL) {
425 GrStringBuilder nameWithStage(name);
426 nameWithStage.appendS32(stageNum);
427 append_varying(type, nameWithStage.c_str(), segments, vsOutName, fsInName);
428 }
429 }
430
genEdgeCoverage(const GrGLContextInfo & gl,GrVertexLayout layout,CachedData * programData,GrStringBuilder * coverageVar,ShaderCodeSegments * segments) const431 void GrGLProgram::genEdgeCoverage(const GrGLContextInfo& gl,
432 GrVertexLayout layout,
433 CachedData* programData,
434 GrStringBuilder* coverageVar,
435 ShaderCodeSegments* segments) const {
436 if (fProgramDesc.fEdgeAANumEdges > 0) {
437 segments->fFSUnis.push_back().set(GrGLShaderVar::kVec3f_Type,
438 GrGLShaderVar::kUniform_TypeModifier,
439 EDGES_UNI_NAME,
440 fProgramDesc.fEdgeAANumEdges);
441 programData->fUniLocations.fEdgesUni = kUseUniform;
442 int count = fProgramDesc.fEdgeAANumEdges;
443 segments->fFSCode.append(
444 "\tvec3 pos = vec3(gl_FragCoord.xy, 1);\n");
445 for (int i = 0; i < count; i++) {
446 segments->fFSCode.append("\tfloat a");
447 segments->fFSCode.appendS32(i);
448 segments->fFSCode.append(" = clamp(dot(" EDGES_UNI_NAME "[");
449 segments->fFSCode.appendS32(i);
450 segments->fFSCode.append("], pos), 0.0, 1.0);\n");
451 }
452 if (fProgramDesc.fEdgeAAConcave && (count & 0x01) == 0) {
453 // For concave polys, we consider the edges in pairs.
454 segments->fFSFunctions.append("float cross2(vec2 a, vec2 b) {\n");
455 segments->fFSFunctions.append("\treturn dot(a, vec2(b.y, -b.x));\n");
456 segments->fFSFunctions.append("}\n");
457 for (int i = 0; i < count; i += 2) {
458 segments->fFSCode.appendf("\tfloat eb%d;\n", i / 2);
459 segments->fFSCode.appendf("\tif (cross2(" EDGES_UNI_NAME "[%d].xy, " EDGES_UNI_NAME "[%d].xy) < 0.0) {\n", i, i + 1);
460 segments->fFSCode.appendf("\t\teb%d = a%d * a%d;\n", i / 2, i, i + 1);
461 segments->fFSCode.append("\t} else {\n");
462 segments->fFSCode.appendf("\t\teb%d = a%d + a%d - a%d * a%d;\n", i / 2, i, i + 1, i, i + 1);
463 segments->fFSCode.append("\t}\n");
464 }
465 segments->fFSCode.append("\tfloat edgeAlpha = ");
466 for (int i = 0; i < count / 2 - 1; i++) {
467 segments->fFSCode.appendf("min(eb%d, ", i);
468 }
469 segments->fFSCode.appendf("eb%d", count / 2 - 1);
470 for (int i = 0; i < count / 2 - 1; i++) {
471 segments->fFSCode.append(")");
472 }
473 segments->fFSCode.append(";\n");
474 } else {
475 segments->fFSCode.append("\tfloat edgeAlpha = ");
476 for (int i = 0; i < count - 1; i++) {
477 segments->fFSCode.appendf("min(a%d * a%d, ", i, i + 1);
478 }
479 segments->fFSCode.appendf("a%d * a0", count - 1);
480 for (int i = 0; i < count - 1; i++) {
481 segments->fFSCode.append(")");
482 }
483 segments->fFSCode.append(";\n");
484 }
485 *coverageVar = "edgeAlpha";
486 } else if (layout & GrDrawTarget::kEdge_VertexLayoutBit) {
487 const char *vsName, *fsName;
488 append_varying(GrGLShaderVar::kVec4f_Type, "Edge", segments,
489 &vsName, &fsName);
490 segments->fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type,
491 GrGLShaderVar::kAttribute_TypeModifier, EDGE_ATTR_NAME);
492 segments->fVSCode.appendf("\t%s = " EDGE_ATTR_NAME ";\n", vsName);
493 if (GrDrawState::kHairLine_EdgeType == fProgramDesc.fVertexEdgeType) {
494 segments->fFSCode.appendf("\tfloat edgeAlpha = abs(dot(vec3(gl_FragCoord.xy,1), %s.xyz));\n", fsName);
495 segments->fFSCode.append("\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
496 } else if (GrDrawState::kQuad_EdgeType == fProgramDesc.fVertexEdgeType) {
497 segments->fFSCode.append("\tfloat edgeAlpha;\n");
498 // keep the derivative instructions outside the conditional
499 segments->fFSCode.appendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
500 segments->fFSCode.appendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
501 segments->fFSCode.appendf("\tif (%s.z > 0.0 && %s.w > 0.0) {\n", fsName, fsName);
502 // today we know z and w are in device space. We could use derivatives
503 segments->fFSCode.appendf("\t\tedgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);\n", fsName, fsName);
504 segments->fFSCode.append ("\t} else {\n");
505 segments->fFSCode.appendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
506 "\t\t 2.0*%s.x*duvdy.x - duvdy.y);\n",
507 fsName, fsName);
508 segments->fFSCode.appendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
509 segments->fFSCode.append("\t\tedgeAlpha = clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);\n"
510 "\t}\n");
511 if (kES2_GrGLBinding == gl.binding()) {
512 segments->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
513 }
514 } else {
515 GrAssert(GrDrawState::kHairQuad_EdgeType == fProgramDesc.fVertexEdgeType);
516 segments->fFSCode.appendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
517 segments->fFSCode.appendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
518 segments->fFSCode.appendf("\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
519 "\t 2.0*%s.x*duvdy.x - duvdy.y);\n",
520 fsName, fsName);
521 segments->fFSCode.appendf("\tfloat edgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
522 segments->fFSCode.append("\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / dot(gF, gF));\n");
523 segments->fFSCode.append("\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
524 if (kES2_GrGLBinding == gl.binding()) {
525 segments->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
526 }
527 }
528 *coverageVar = "edgeAlpha";
529 } else {
530 coverageVar->reset();
531 }
532 }
533
534 namespace {
535
genInputColor(GrGLProgram::ProgramDesc::ColorInput colorInput,GrGLProgram::CachedData * programData,ShaderCodeSegments * segments,GrStringBuilder * inColor)536 void genInputColor(GrGLProgram::ProgramDesc::ColorInput colorInput,
537 GrGLProgram::CachedData* programData,
538 ShaderCodeSegments* segments,
539 GrStringBuilder* inColor) {
540 switch (colorInput) {
541 case GrGLProgram::ProgramDesc::kAttribute_ColorInput: {
542 segments->fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type,
543 GrGLShaderVar::kAttribute_TypeModifier,
544 COL_ATTR_NAME);
545 const char *vsName, *fsName;
546 append_varying(GrGLShaderVar::kVec4f_Type, "Color", segments, &vsName, &fsName);
547 segments->fVSCode.appendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
548 *inColor = fsName;
549 } break;
550 case GrGLProgram::ProgramDesc::kUniform_ColorInput:
551 segments->fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
552 GrGLShaderVar::kUniform_TypeModifier,
553 COL_UNI_NAME);
554 programData->fUniLocations.fColorUni = kUseUniform;
555 *inColor = COL_UNI_NAME;
556 break;
557 case GrGLProgram::ProgramDesc::kTransBlack_ColorInput:
558 GrAssert(!"needComputedColor should be false.");
559 break;
560 case GrGLProgram::ProgramDesc::kSolidWhite_ColorInput:
561 break;
562 default:
563 GrCrash("Unknown color type.");
564 break;
565 }
566 }
567
genAttributeCoverage(ShaderCodeSegments * segments,GrStringBuilder * inOutCoverage)568 void genAttributeCoverage(ShaderCodeSegments* segments,
569 GrStringBuilder* inOutCoverage) {
570 segments->fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type,
571 GrGLShaderVar::kAttribute_TypeModifier,
572 COV_ATTR_NAME);
573 const char *vsName, *fsName;
574 append_varying(GrGLShaderVar::kVec4f_Type, "Coverage",
575 segments, &vsName, &fsName);
576 segments->fVSCode.appendf("\t%s = " COV_ATTR_NAME ";\n", vsName);
577 if (inOutCoverage->size()) {
578 segments->fFSCode.appendf("\tvec4 attrCoverage = %s * %s;\n",
579 fsName, inOutCoverage->c_str());
580 *inOutCoverage = "attrCoverage";
581 } else {
582 *inOutCoverage = fsName;
583 }
584 }
585
genUniformCoverage(ShaderCodeSegments * segments,GrGLProgram::CachedData * programData,GrStringBuilder * inOutCoverage)586 void genUniformCoverage(ShaderCodeSegments* segments,
587 GrGLProgram::CachedData* programData,
588 GrStringBuilder* inOutCoverage) {
589 segments->fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
590 GrGLShaderVar::kUniform_TypeModifier,
591 COV_UNI_NAME);
592 programData->fUniLocations.fCoverageUni = kUseUniform;
593 if (inOutCoverage->size()) {
594 segments->fFSCode.appendf("\tvec4 uniCoverage = %s * %s;\n",
595 COV_UNI_NAME, inOutCoverage->c_str());
596 *inOutCoverage = "uniCoverage";
597 } else {
598 *inOutCoverage = COV_UNI_NAME;
599 }
600 }
601
602 }
603
genGeometryShader(const GrGLContextInfo & gl,ShaderCodeSegments * segments) const604 void GrGLProgram::genGeometryShader(const GrGLContextInfo& gl,
605 ShaderCodeSegments* segments) const {
606 #if GR_GL_EXPERIMENTAL_GS
607 if (fProgramDesc.fExperimentalGS) {
608 GrAssert(gl.glslGeneration() >= k150_GrGLSLGeneration);
609 segments->fGSHeader.append("layout(triangles) in;\n"
610 "layout(triangle_strip, max_vertices = 6) out;\n");
611 segments->fGSCode.append("void main() {\n"
612 "\tfor (int i = 0; i < 3; ++i) {\n"
613 "\t\tgl_Position = gl_in[i].gl_Position;\n");
614 if (this->fProgramDesc.fEmitsPointSize) {
615 segments->fGSCode.append("\t\tgl_PointSize = 1.0;\n");
616 }
617 GrAssert(segments->fGSInputs.count() == segments->fGSOutputs.count());
618 int count = segments->fGSInputs.count();
619 for (int i = 0; i < count; ++i) {
620 segments->fGSCode.appendf("\t\t%s = %s[i];\n",
621 segments->fGSOutputs[i].getName().c_str(),
622 segments->fGSInputs[i].getName().c_str());
623 }
624 segments->fGSCode.append("\t\tEmitVertex();\n"
625 "\t}\n"
626 "\tEndPrimitive();\n"
627 "}\n");
628 }
629 #endif
630 }
631
adjustInColor(const GrStringBuilder & inColor) const632 const char* GrGLProgram::adjustInColor(const GrStringBuilder& inColor) const {
633 if (inColor.size()) {
634 return inColor.c_str();
635 } else {
636 if (ProgramDesc::kSolidWhite_ColorInput == fProgramDesc.fColorInput) {
637 return all_ones_vec(4);
638 } else {
639 return all_zeros_vec(4);
640 }
641 }
642 }
643
644
genProgram(const GrGLContextInfo & gl,GrGLProgram::CachedData * programData) const645 bool GrGLProgram::genProgram(const GrGLContextInfo& gl,
646 GrGLProgram::CachedData* programData) const {
647
648 ShaderCodeSegments segments;
649 const uint32_t& layout = fProgramDesc.fVertexLayout;
650
651 programData->fUniLocations.reset();
652
653 #if GR_GL_EXPERIMENTAL_GS
654 segments.fUsesGS = fProgramDesc.fExperimentalGS;
655 #endif
656
657 SkXfermode::Coeff colorCoeff, uniformCoeff;
658 bool applyColorMatrix = SkToBool(fProgramDesc.fColorMatrixEnabled);
659 // The rest of transfer mode color filters have not been implemented
660 if (fProgramDesc.fColorFilterXfermode < SkXfermode::kCoeffModesCnt) {
661 GR_DEBUGCODE(bool success =)
662 SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>
663 (fProgramDesc.fColorFilterXfermode),
664 &uniformCoeff, &colorCoeff);
665 GR_DEBUGASSERT(success);
666 } else {
667 colorCoeff = SkXfermode::kOne_Coeff;
668 uniformCoeff = SkXfermode::kZero_Coeff;
669 }
670
671 // no need to do the color filter / matrix at all if coverage is 0. The
672 // output color is scaled by the coverage. All the dual source outputs are
673 // scaled by the coverage as well.
674 if (ProgramDesc::kTransBlack_ColorInput == fProgramDesc.fCoverageInput) {
675 colorCoeff = SkXfermode::kZero_Coeff;
676 uniformCoeff = SkXfermode::kZero_Coeff;
677 applyColorMatrix = false;
678 }
679
680 // If we know the final color is going to be all zeros then we can
681 // simplify the color filter coeffecients. needComputedColor will then
682 // come out false below.
683 if (ProgramDesc::kTransBlack_ColorInput == fProgramDesc.fColorInput) {
684 colorCoeff = SkXfermode::kZero_Coeff;
685 if (SkXfermode::kDC_Coeff == uniformCoeff ||
686 SkXfermode::kDA_Coeff == uniformCoeff) {
687 uniformCoeff = SkXfermode::kZero_Coeff;
688 } else if (SkXfermode::kIDC_Coeff == uniformCoeff ||
689 SkXfermode::kIDA_Coeff == uniformCoeff) {
690 uniformCoeff = SkXfermode::kOne_Coeff;
691 }
692 }
693
694 bool needColorFilterUniform;
695 bool needComputedColor;
696 needBlendInputs(uniformCoeff, colorCoeff,
697 &needColorFilterUniform, &needComputedColor);
698
699 // the dual source output has no canonical var name, have to
700 // declare an output, which is incompatible with gl_FragColor/gl_FragData.
701 bool dualSourceOutputWritten = false;
702 segments.fHeader.printf(GrGetGLSLVersionDecl(gl.binding(),
703 gl.glslGeneration()));
704
705 GrGLShaderVar colorOutput;
706 bool isColorDeclared = GrGLSLSetupFSColorOuput(gl.glslGeneration(),
707 declared_color_output_name(),
708 &colorOutput);
709 if (isColorDeclared) {
710 segments.fFSOutputs.push_back(colorOutput);
711 }
712
713 #if GR_GL_ATTRIBUTE_MATRICES
714 segments.fVSAttrs.push_back().set(GrGLShaderVar::kMat33f_Type,
715 GrGLShaderVar::kAttribute_TypeModifier, VIEW_MATRIX_NAME);
716 programData->fUniLocations.fViewMatrixUni = kSetAsAttribute;
717 #else
718 segments.fVSUnis.push_back().set(GrGLShaderVar::kMat33f_Type,
719 GrGLShaderVar::kUniform_TypeModifier, VIEW_MATRIX_NAME);
720 programData->fUniLocations.fViewMatrixUni = kUseUniform;
721 #endif
722 segments.fVSAttrs.push_back().set(GrGLShaderVar::kVec2f_Type,
723 GrGLShaderVar::kAttribute_TypeModifier, POS_ATTR_NAME);
724
725 segments.fVSCode.append(
726 "void main() {\n"
727 "\tvec3 pos3 = " VIEW_MATRIX_NAME " * vec3("POS_ATTR_NAME", 1);\n"
728 "\tgl_Position = vec4(pos3.xy, 0, pos3.z);\n");
729
730 // incoming color to current stage being processed.
731 GrStringBuilder inColor;
732
733 if (needComputedColor) {
734 genInputColor((ProgramDesc::ColorInput) fProgramDesc.fColorInput,
735 programData, &segments, &inColor);
736 }
737
738 // we output point size in the GS if present
739 if (fProgramDesc.fEmitsPointSize && !segments.fUsesGS){
740 segments.fVSCode.append("\tgl_PointSize = 1.0;\n");
741 }
742
743 segments.fFSCode.append("void main() {\n");
744
745 // add texture coordinates that are used to the list of vertex attr decls
746 GrStringBuilder texCoordAttrs[GrDrawState::kMaxTexCoords];
747 for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
748 if (GrDrawTarget::VertexUsesTexCoordIdx(t, layout)) {
749 tex_attr_name(t, texCoordAttrs + t);
750 segments.fVSAttrs.push_back().set(GrGLShaderVar::kVec2f_Type,
751 GrGLShaderVar::kAttribute_TypeModifier,
752 texCoordAttrs[t].c_str());
753 }
754 }
755
756 ///////////////////////////////////////////////////////////////////////////
757 // compute the final color
758
759 // if we have color stages string them together, feeding the output color
760 // of each to the next and generating code for each stage.
761 if (needComputedColor) {
762 GrStringBuilder outColor;
763 for (int s = 0; s < fProgramDesc.fFirstCoverageStage; ++s) {
764 if (fProgramDesc.fStages[s].isEnabled()) {
765 // create var to hold stage result
766 outColor = "color";
767 outColor.appendS32(s);
768 segments.fFSCode.appendf("\tvec4 %s;\n", outColor.c_str());
769
770 const char* inCoords;
771 // figure out what our input coords are
772 if (GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(s) &
773 layout) {
774 inCoords = POS_ATTR_NAME;
775 } else {
776 int tcIdx = GrDrawTarget::VertexTexCoordsForStage(s, layout);
777 // we better have input tex coordinates if stage is enabled.
778 GrAssert(tcIdx >= 0);
779 GrAssert(texCoordAttrs[tcIdx].size());
780 inCoords = texCoordAttrs[tcIdx].c_str();
781 }
782
783 this->genStageCode(gl,
784 s,
785 fProgramDesc.fStages[s],
786 inColor.size() ? inColor.c_str() : NULL,
787 outColor.c_str(),
788 inCoords,
789 &segments,
790 &programData->fUniLocations.fStages[s]);
791 inColor = outColor;
792 }
793 }
794 }
795
796 // if have all ones or zeros for the "dst" input to the color filter then we
797 // may be able to make additional optimizations.
798 if (needColorFilterUniform && needComputedColor && !inColor.size()) {
799 GrAssert(ProgramDesc::kSolidWhite_ColorInput == fProgramDesc.fColorInput);
800 bool uniformCoeffIsZero = SkXfermode::kIDC_Coeff == uniformCoeff ||
801 SkXfermode::kIDA_Coeff == uniformCoeff;
802 if (uniformCoeffIsZero) {
803 uniformCoeff = SkXfermode::kZero_Coeff;
804 bool bogus;
805 needBlendInputs(SkXfermode::kZero_Coeff, colorCoeff,
806 &needColorFilterUniform, &bogus);
807 }
808 }
809 if (needColorFilterUniform) {
810 segments.fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
811 GrGLShaderVar::kUniform_TypeModifier,
812 COL_FILTER_UNI_NAME);
813 programData->fUniLocations.fColorFilterUni = kUseUniform;
814 }
815 bool wroteFragColorZero = false;
816 if (SkXfermode::kZero_Coeff == uniformCoeff &&
817 SkXfermode::kZero_Coeff == colorCoeff &&
818 !applyColorMatrix) {
819 segments.fFSCode.appendf("\t%s = %s;\n",
820 colorOutput.getName().c_str(),
821 all_zeros_vec(4));
822 wroteFragColorZero = true;
823 } else if (SkXfermode::kDst_Mode != fProgramDesc.fColorFilterXfermode) {
824 segments.fFSCode.append("\tvec4 filteredColor;\n");
825 const char* color = adjustInColor(inColor);
826 addColorFilter(&segments.fFSCode, "filteredColor", uniformCoeff,
827 colorCoeff, color);
828 inColor = "filteredColor";
829 }
830 if (applyColorMatrix) {
831 segments.fFSUnis.push_back().set(GrGLShaderVar::kMat44f_Type,
832 GrGLShaderVar::kUniform_TypeModifier,
833 COL_MATRIX_UNI_NAME);
834 segments.fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
835 GrGLShaderVar::kUniform_TypeModifier,
836 COL_MATRIX_VEC_UNI_NAME);
837 programData->fUniLocations.fColorMatrixUni = kUseUniform;
838 programData->fUniLocations.fColorMatrixVecUni = kUseUniform;
839 segments.fFSCode.append("\tvec4 matrixedColor;\n");
840 const char* color = adjustInColor(inColor);
841 addColorMatrix(&segments.fFSCode, "matrixedColor", color);
842 inColor = "matrixedColor";
843 }
844
845 ///////////////////////////////////////////////////////////////////////////
846 // compute the partial coverage (coverage stages and edge aa)
847
848 GrStringBuilder inCoverage;
849 bool coverageIsZero = ProgramDesc::kTransBlack_ColorInput ==
850 fProgramDesc.fCoverageInput;
851 // we don't need to compute coverage at all if we know the final shader
852 // output will be zero and we don't have a dual src blend output.
853 if (!wroteFragColorZero ||
854 ProgramDesc::kNone_DualSrcOutput != fProgramDesc.fDualSrcOutput) {
855
856 if (!coverageIsZero) {
857 this->genEdgeCoverage(gl,
858 layout,
859 programData,
860 &inCoverage,
861 &segments);
862
863 switch (fProgramDesc.fCoverageInput) {
864 case ProgramDesc::kSolidWhite_ColorInput:
865 // empty string implies solid white
866 break;
867 case ProgramDesc::kAttribute_ColorInput:
868 genAttributeCoverage(&segments, &inCoverage);
869 break;
870 case ProgramDesc::kUniform_ColorInput:
871 genUniformCoverage(&segments, programData, &inCoverage);
872 break;
873 default:
874 GrCrash("Unexpected input coverage.");
875 }
876
877 GrStringBuilder outCoverage;
878 const int& startStage = fProgramDesc.fFirstCoverageStage;
879 for (int s = startStage; s < GrDrawState::kNumStages; ++s) {
880 if (fProgramDesc.fStages[s].isEnabled()) {
881 // create var to hold stage output
882 outCoverage = "coverage";
883 outCoverage.appendS32(s);
884 segments.fFSCode.appendf("\tvec4 %s;\n",
885 outCoverage.c_str());
886
887 const char* inCoords;
888 // figure out what our input coords are
889 if (GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(s) &
890 layout) {
891 inCoords = POS_ATTR_NAME;
892 } else {
893 int tcIdx =
894 GrDrawTarget::VertexTexCoordsForStage(s, layout);
895 // we better have input tex coordinates if stage is
896 // enabled.
897 GrAssert(tcIdx >= 0);
898 GrAssert(texCoordAttrs[tcIdx].size());
899 inCoords = texCoordAttrs[tcIdx].c_str();
900 }
901
902 genStageCode(gl, s,
903 fProgramDesc.fStages[s],
904 inCoverage.size() ? inCoverage.c_str() : NULL,
905 outCoverage.c_str(),
906 inCoords,
907 &segments,
908 &programData->fUniLocations.fStages[s]);
909 inCoverage = outCoverage;
910 }
911 }
912 }
913 if (ProgramDesc::kNone_DualSrcOutput != fProgramDesc.fDualSrcOutput) {
914 segments.fFSOutputs.push_back().set(GrGLShaderVar::kVec4f_Type,
915 GrGLShaderVar::kOut_TypeModifier,
916 dual_source_output_name());
917 bool outputIsZero = coverageIsZero;
918 GrStringBuilder coeff;
919 if (!outputIsZero &&
920 ProgramDesc::kCoverage_DualSrcOutput !=
921 fProgramDesc.fDualSrcOutput && !wroteFragColorZero) {
922 if (!inColor.size()) {
923 outputIsZero = true;
924 } else {
925 if (fProgramDesc.fDualSrcOutput ==
926 ProgramDesc::kCoverageISA_DualSrcOutput) {
927 coeff.printf("(1 - %s.a)", inColor.c_str());
928 } else {
929 coeff.printf("(vec4(1,1,1,1) - %s)", inColor.c_str());
930 }
931 }
932 }
933 if (outputIsZero) {
934 segments.fFSCode.appendf("\t%s = %s;\n",
935 dual_source_output_name(),
936 all_zeros_vec(4));
937 } else {
938 modulate_helper(dual_source_output_name(),
939 coeff.c_str(),
940 inCoverage.c_str(),
941 &segments.fFSCode);
942 }
943 dualSourceOutputWritten = true;
944 }
945 }
946
947 ///////////////////////////////////////////////////////////////////////////
948 // combine color and coverage as frag color
949
950 if (!wroteFragColorZero) {
951 if (coverageIsZero) {
952 segments.fFSCode.appendf("\t%s = %s;\n",
953 colorOutput.getName().c_str(),
954 all_zeros_vec(4));
955 } else {
956 modulate_helper(colorOutput.getName().c_str(),
957 inColor.c_str(),
958 inCoverage.c_str(),
959 &segments.fFSCode);
960 }
961 if (ProgramDesc::kUnpremultiplied_RoundDown_OutputConfig ==
962 fProgramDesc.fOutputConfig) {
963 segments.fFSCode.appendf("\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(floor(%s.rgb / %s.a * 255.0)/255.0, %s.a);\n",
964 colorOutput.getName().c_str(),
965 colorOutput.getName().c_str(),
966 colorOutput.getName().c_str(),
967 colorOutput.getName().c_str(),
968 colorOutput.getName().c_str());
969 } else if (ProgramDesc::kUnpremultiplied_RoundUp_OutputConfig ==
970 fProgramDesc.fOutputConfig) {
971 segments.fFSCode.appendf("\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(ceil(%s.rgb / %s.a * 255.0)/255.0, %s.a);\n",
972 colorOutput.getName().c_str(),
973 colorOutput.getName().c_str(),
974 colorOutput.getName().c_str(),
975 colorOutput.getName().c_str(),
976 colorOutput.getName().c_str());
977 }
978 }
979
980 segments.fVSCode.append("}\n");
981 segments.fFSCode.append("}\n");
982
983 ///////////////////////////////////////////////////////////////////////////
984 // insert GS
985 #if GR_DEBUG
986 this->genGeometryShader(gl, &segments);
987 #endif
988
989 ///////////////////////////////////////////////////////////////////////////
990 // compile and setup attribs and unis
991
992 if (!CompileShaders(gl, segments, programData)) {
993 return false;
994 }
995
996 if (!this->bindOutputsAttribsAndLinkProgram(gl, texCoordAttrs,
997 isColorDeclared,
998 dualSourceOutputWritten,
999 programData)) {
1000 return false;
1001 }
1002
1003 this->getUniformLocationsAndInitCache(gl, programData);
1004
1005 return true;
1006 }
1007
1008 namespace {
1009
expand_decls(const VarArray & vars,const GrGLContextInfo & gl,GrStringBuilder * string)1010 inline void expand_decls(const VarArray& vars,
1011 const GrGLContextInfo& gl,
1012 GrStringBuilder* string) {
1013 const int count = vars.count();
1014 for (int i = 0; i < count; ++i) {
1015 vars[i].appendDecl(gl, string);
1016 }
1017 }
1018
print_shader(int stringCnt,const char ** strings,int * stringLengths)1019 inline void print_shader(int stringCnt,
1020 const char** strings,
1021 int* stringLengths) {
1022 for (int i = 0; i < stringCnt; ++i) {
1023 if (NULL == stringLengths || stringLengths[i] < 0) {
1024 GrPrintf(strings[i]);
1025 } else {
1026 GrPrintf("%.*s", stringLengths[i], strings[i]);
1027 }
1028 }
1029 }
1030
1031 typedef SkTArray<const char*, true> StrArray;
1032 #define PREALLOC_STR_ARRAY(N) SkSTArray<(N), const char*, true>
1033
1034 typedef SkTArray<int, true> LengthArray;
1035 #define PREALLOC_LENGTH_ARRAY(N) SkSTArray<(N), int, true>
1036
1037 // these shouldn't relocate
1038 typedef GrTAllocator<GrStringBuilder> TempArray;
1039 #define PREALLOC_TEMP_ARRAY(N) GrSTAllocator<(N), GrStringBuilder>
1040
append_string(const GrStringBuilder & str,StrArray * strings,LengthArray * lengths)1041 inline void append_string(const GrStringBuilder& str,
1042 StrArray* strings,
1043 LengthArray* lengths) {
1044 int length = (int) str.size();
1045 if (length) {
1046 strings->push_back(str.c_str());
1047 lengths->push_back(length);
1048 }
1049 GrAssert(strings->count() == lengths->count());
1050 }
1051
append_decls(const VarArray & vars,const GrGLContextInfo & gl,StrArray * strings,LengthArray * lengths,TempArray * temp)1052 inline void append_decls(const VarArray& vars,
1053 const GrGLContextInfo& gl,
1054 StrArray* strings,
1055 LengthArray* lengths,
1056 TempArray* temp) {
1057 expand_decls(vars, gl, &temp->push_back());
1058 append_string(temp->back(), strings, lengths);
1059 }
1060
1061 }
1062
CompileShaders(const GrGLContextInfo & gl,const ShaderCodeSegments & segments,CachedData * programData)1063 bool GrGLProgram::CompileShaders(const GrGLContextInfo& gl,
1064 const ShaderCodeSegments& segments,
1065 CachedData* programData) {
1066 enum { kPreAllocStringCnt = 8 };
1067
1068 PREALLOC_STR_ARRAY(kPreAllocStringCnt) strs;
1069 PREALLOC_LENGTH_ARRAY(kPreAllocStringCnt) lengths;
1070 PREALLOC_TEMP_ARRAY(kPreAllocStringCnt) temps;
1071
1072 GrStringBuilder unis;
1073 GrStringBuilder inputs;
1074 GrStringBuilder outputs;
1075
1076 append_string(segments.fHeader, &strs, &lengths);
1077 append_decls(segments.fVSUnis, gl, &strs, &lengths, &temps);
1078 append_decls(segments.fVSAttrs, gl, &strs, &lengths, &temps);
1079 append_decls(segments.fVSOutputs, gl, &strs, &lengths, &temps);
1080 append_string(segments.fVSCode, &strs, &lengths);
1081
1082 #if PRINT_SHADERS
1083 print_shader(strs.count(), &strs[0], &lengths[0]);
1084 GrPrintf("\n");
1085 #endif
1086
1087 programData->fVShaderID =
1088 CompileShader(gl, GR_GL_VERTEX_SHADER, strs.count(),
1089 &strs[0], &lengths[0]);
1090
1091 if (!programData->fVShaderID) {
1092 return false;
1093 }
1094 if (segments.fUsesGS) {
1095 strs.reset();
1096 lengths.reset();
1097 temps.reset();
1098 append_string(segments.fHeader, &strs, &lengths);
1099 append_string(segments.fGSHeader, &strs, &lengths);
1100 append_decls(segments.fGSInputs, gl, &strs, &lengths, &temps);
1101 append_decls(segments.fGSOutputs, gl, &strs, &lengths, &temps);
1102 append_string(segments.fGSCode, &strs, &lengths);
1103 #if PRINT_SHADERS
1104 print_shader(strs.count(), &strs[0], &lengths[0]);
1105 GrPrintf("\n");
1106 #endif
1107 programData->fGShaderID =
1108 CompileShader(gl, GR_GL_GEOMETRY_SHADER, strs.count(),
1109 &strs[0], &lengths[0]);
1110 } else {
1111 programData->fGShaderID = 0;
1112 }
1113
1114 strs.reset();
1115 lengths.reset();
1116 temps.reset();
1117
1118 append_string(segments.fHeader, &strs, &lengths);
1119 GrStringBuilder precisionStr(GrGetGLSLShaderPrecisionDecl(gl.binding()));
1120 append_string(precisionStr, &strs, &lengths);
1121 append_decls(segments.fFSUnis, gl, &strs, &lengths, &temps);
1122 append_decls(segments.fFSInputs, gl, &strs, &lengths, &temps);
1123 // We shouldn't have declared outputs on 1.10
1124 GrAssert(k110_GrGLSLGeneration != gl.glslGeneration() ||
1125 segments.fFSOutputs.empty());
1126 append_decls(segments.fFSOutputs, gl, &strs, &lengths, &temps);
1127 append_string(segments.fFSFunctions, &strs, &lengths);
1128 append_string(segments.fFSCode, &strs, &lengths);
1129
1130 #if PRINT_SHADERS
1131 print_shader(strs.count(), &strs[0], &lengths[0]);
1132 GrPrintf("\n");
1133 #endif
1134
1135 programData->fFShaderID =
1136 CompileShader(gl, GR_GL_FRAGMENT_SHADER, strs.count(),
1137 &strs[0], &lengths[0]);
1138
1139 if (!programData->fFShaderID) {
1140 return false;
1141 }
1142
1143 return true;
1144 }
1145
1146 #define GL_CALL(X) GR_GL_CALL(gl.interface(), X)
1147 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(gl.interface(), R, X)
1148
CompileShader(const GrGLContextInfo & gl,GrGLenum type,int stringCnt,const char ** strings,int * stringLengths)1149 GrGLuint GrGLProgram::CompileShader(const GrGLContextInfo& gl,
1150 GrGLenum type,
1151 int stringCnt,
1152 const char** strings,
1153 int* stringLengths) {
1154 SK_TRACE_EVENT1("GrGLProgram::CompileShader",
1155 "stringCount", SkStringPrintf("%i", stringCnt).c_str());
1156
1157 GrGLuint shader;
1158 GL_CALL_RET(shader, CreateShader(type));
1159 if (0 == shader) {
1160 return 0;
1161 }
1162
1163 GrGLint compiled = GR_GL_INIT_ZERO;
1164 GL_CALL(ShaderSource(shader, stringCnt, strings, stringLengths));
1165 GL_CALL(CompileShader(shader));
1166 GL_CALL(GetShaderiv(shader, GR_GL_COMPILE_STATUS, &compiled));
1167
1168 if (!compiled) {
1169 GrGLint infoLen = GR_GL_INIT_ZERO;
1170 GL_CALL(GetShaderiv(shader, GR_GL_INFO_LOG_LENGTH, &infoLen));
1171 SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
1172 if (infoLen > 0) {
1173 // retrieve length even though we don't need it to workaround
1174 // bug in chrome cmd buffer param validation.
1175 GrGLsizei length = GR_GL_INIT_ZERO;
1176 GL_CALL(GetShaderInfoLog(shader, infoLen+1,
1177 &length, (char*)log.get()));
1178 print_shader(stringCnt, strings, stringLengths);
1179 GrPrintf("\n%s", log.get());
1180 }
1181 GrAssert(!"Shader compilation failed!");
1182 GL_CALL(DeleteShader(shader));
1183 return 0;
1184 }
1185 return shader;
1186 }
1187
bindOutputsAttribsAndLinkProgram(const GrGLContextInfo & gl,GrStringBuilder texCoordAttrNames[],bool bindColorOut,bool bindDualSrcOut,CachedData * programData) const1188 bool GrGLProgram::bindOutputsAttribsAndLinkProgram(
1189 const GrGLContextInfo& gl,
1190 GrStringBuilder texCoordAttrNames[],
1191 bool bindColorOut,
1192 bool bindDualSrcOut,
1193 CachedData* programData) const {
1194 GL_CALL_RET(programData->fProgramID, CreateProgram());
1195 if (!programData->fProgramID) {
1196 return false;
1197 }
1198 const GrGLint& progID = programData->fProgramID;
1199
1200 GL_CALL(AttachShader(progID, programData->fVShaderID));
1201 if (programData->fGShaderID) {
1202 GL_CALL(AttachShader(progID, programData->fGShaderID));
1203 }
1204 GL_CALL(AttachShader(progID, programData->fFShaderID));
1205
1206 if (bindColorOut) {
1207 GL_CALL(BindFragDataLocation(programData->fProgramID,
1208 0, declared_color_output_name()));
1209 }
1210 if (bindDualSrcOut) {
1211 GL_CALL(BindFragDataLocationIndexed(programData->fProgramID,
1212 0, 1, dual_source_output_name()));
1213 }
1214
1215 // Bind the attrib locations to same values for all shaders
1216 GL_CALL(BindAttribLocation(progID, PositionAttributeIdx(), POS_ATTR_NAME));
1217 for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
1218 if (texCoordAttrNames[t].size()) {
1219 GL_CALL(BindAttribLocation(progID,
1220 TexCoordAttributeIdx(t),
1221 texCoordAttrNames[t].c_str()));
1222 }
1223 }
1224
1225 if (kSetAsAttribute == programData->fUniLocations.fViewMatrixUni) {
1226 GL_CALL(BindAttribLocation(progID,
1227 ViewMatrixAttributeIdx(),
1228 VIEW_MATRIX_NAME));
1229 }
1230
1231 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
1232 const StageUniLocations& unis = programData->fUniLocations.fStages[s];
1233 if (kSetAsAttribute == unis.fTextureMatrixUni) {
1234 GrStringBuilder matName;
1235 tex_matrix_name(s, &matName);
1236 GL_CALL(BindAttribLocation(progID,
1237 TextureMatrixAttributeIdx(s),
1238 matName.c_str()));
1239 }
1240 }
1241
1242 GL_CALL(BindAttribLocation(progID, ColorAttributeIdx(), COL_ATTR_NAME));
1243 GL_CALL(BindAttribLocation(progID, CoverageAttributeIdx(), COV_ATTR_NAME));
1244 GL_CALL(BindAttribLocation(progID, EdgeAttributeIdx(), EDGE_ATTR_NAME));
1245
1246 GL_CALL(LinkProgram(progID));
1247
1248 GrGLint linked = GR_GL_INIT_ZERO;
1249 GL_CALL(GetProgramiv(progID, GR_GL_LINK_STATUS, &linked));
1250 if (!linked) {
1251 GrGLint infoLen = GR_GL_INIT_ZERO;
1252 GL_CALL(GetProgramiv(progID, GR_GL_INFO_LOG_LENGTH, &infoLen));
1253 SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
1254 if (infoLen > 0) {
1255 // retrieve length even though we don't need it to workaround
1256 // bug in chrome cmd buffer param validation.
1257 GrGLsizei length = GR_GL_INIT_ZERO;
1258 GL_CALL(GetProgramInfoLog(progID,
1259 infoLen+1,
1260 &length,
1261 (char*)log.get()));
1262 GrPrintf((char*)log.get());
1263 }
1264 GrAssert(!"Error linking program");
1265 GL_CALL(DeleteProgram(progID));
1266 programData->fProgramID = 0;
1267 return false;
1268 }
1269 return true;
1270 }
1271
getUniformLocationsAndInitCache(const GrGLContextInfo & gl,CachedData * programData) const1272 void GrGLProgram::getUniformLocationsAndInitCache(const GrGLContextInfo& gl,
1273 CachedData* programData) const {
1274 const GrGLint& progID = programData->fProgramID;
1275
1276 if (kUseUniform == programData->fUniLocations.fViewMatrixUni) {
1277 GL_CALL_RET(programData->fUniLocations.fViewMatrixUni,
1278 GetUniformLocation(progID, VIEW_MATRIX_NAME));
1279 GrAssert(kUnusedUniform != programData->fUniLocations.fViewMatrixUni);
1280 }
1281 if (kUseUniform == programData->fUniLocations.fColorUni) {
1282 GL_CALL_RET(programData->fUniLocations.fColorUni,
1283 GetUniformLocation(progID, COL_UNI_NAME));
1284 GrAssert(kUnusedUniform != programData->fUniLocations.fColorUni);
1285 }
1286 if (kUseUniform == programData->fUniLocations.fColorFilterUni) {
1287 GL_CALL_RET(programData->fUniLocations.fColorFilterUni,
1288 GetUniformLocation(progID, COL_FILTER_UNI_NAME));
1289 GrAssert(kUnusedUniform != programData->fUniLocations.fColorFilterUni);
1290 }
1291
1292 if (kUseUniform == programData->fUniLocations.fColorMatrixUni) {
1293 GL_CALL_RET(programData->fUniLocations.fColorMatrixUni,
1294 GetUniformLocation(progID, COL_MATRIX_UNI_NAME));
1295 }
1296
1297 if (kUseUniform == programData->fUniLocations.fColorMatrixVecUni) {
1298 GL_CALL_RET(programData->fUniLocations.fColorMatrixVecUni,
1299 GetUniformLocation(progID, COL_MATRIX_VEC_UNI_NAME));
1300 }
1301 if (kUseUniform == programData->fUniLocations.fCoverageUni) {
1302 GL_CALL_RET(programData->fUniLocations.fCoverageUni,
1303 GetUniformLocation(progID, COV_UNI_NAME));
1304 GrAssert(kUnusedUniform != programData->fUniLocations.fCoverageUni);
1305 }
1306
1307 if (kUseUniform == programData->fUniLocations.fEdgesUni) {
1308 GL_CALL_RET(programData->fUniLocations.fEdgesUni,
1309 GetUniformLocation(progID, EDGES_UNI_NAME));
1310 GrAssert(kUnusedUniform != programData->fUniLocations.fEdgesUni);
1311 } else {
1312 programData->fUniLocations.fEdgesUni = kUnusedUniform;
1313 }
1314
1315 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
1316 StageUniLocations& locations = programData->fUniLocations.fStages[s];
1317 if (fProgramDesc.fStages[s].isEnabled()) {
1318 if (kUseUniform == locations.fTextureMatrixUni) {
1319 GrStringBuilder texMName;
1320 tex_matrix_name(s, &texMName);
1321 GL_CALL_RET(locations.fTextureMatrixUni,
1322 GetUniformLocation(progID, texMName.c_str()));
1323 GrAssert(kUnusedUniform != locations.fTextureMatrixUni);
1324 }
1325
1326 if (kUseUniform == locations.fSamplerUni) {
1327 GrStringBuilder samplerName;
1328 sampler_name(s, &samplerName);
1329 GL_CALL_RET(locations.fSamplerUni,
1330 GetUniformLocation(progID,samplerName.c_str()));
1331 GrAssert(kUnusedUniform != locations.fSamplerUni);
1332 }
1333
1334 if (kUseUniform == locations.fNormalizedTexelSizeUni) {
1335 GrStringBuilder texelSizeName;
1336 normalized_texel_size_name(s, &texelSizeName);
1337 GL_CALL_RET(locations.fNormalizedTexelSizeUni,
1338 GetUniformLocation(progID, texelSizeName.c_str()));
1339 GrAssert(kUnusedUniform != locations.fNormalizedTexelSizeUni);
1340 }
1341
1342 if (kUseUniform == locations.fRadial2Uni) {
1343 GrStringBuilder radial2ParamName;
1344 radial2_param_name(s, &radial2ParamName);
1345 GL_CALL_RET(locations.fRadial2Uni,
1346 GetUniformLocation(progID, radial2ParamName.c_str()));
1347 GrAssert(kUnusedUniform != locations.fRadial2Uni);
1348 }
1349
1350 if (kUseUniform == locations.fTexDomUni) {
1351 GrStringBuilder texDomName;
1352 tex_domain_name(s, &texDomName);
1353 GL_CALL_RET(locations.fTexDomUni,
1354 GetUniformLocation(progID, texDomName.c_str()));
1355 GrAssert(kUnusedUniform != locations.fTexDomUni);
1356 }
1357
1358 GrStringBuilder kernelName, imageIncrementName;
1359 convolve_param_names(s, &kernelName, &imageIncrementName);
1360 if (kUseUniform == locations.fKernelUni) {
1361 GL_CALL_RET(locations.fKernelUni,
1362 GetUniformLocation(progID, kernelName.c_str()));
1363 GrAssert(kUnusedUniform != locations.fKernelUni);
1364 }
1365
1366 if (kUseUniform == locations.fImageIncrementUni) {
1367 GL_CALL_RET(locations.fImageIncrementUni,
1368 GetUniformLocation(progID,
1369 imageIncrementName.c_str()));
1370 GrAssert(kUnusedUniform != locations.fImageIncrementUni);
1371 }
1372 }
1373 }
1374 GL_CALL(UseProgram(progID));
1375
1376 // init sampler unis and set bogus values for state tracking
1377 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
1378 if (kUnusedUniform != programData->fUniLocations.fStages[s].fSamplerUni) {
1379 GL_CALL(Uniform1i(programData->fUniLocations.fStages[s].fSamplerUni, s));
1380 }
1381 programData->fTextureMatrices[s] = GrMatrix::InvalidMatrix();
1382 programData->fRadial2CenterX1[s] = GR_ScalarMax;
1383 programData->fRadial2Radius0[s] = -GR_ScalarMax;
1384 programData->fTextureWidth[s] = -1;
1385 programData->fTextureHeight[s] = -1;
1386 }
1387 programData->fViewMatrix = GrMatrix::InvalidMatrix();
1388 programData->fColor = GrColor_ILLEGAL;
1389 programData->fColorFilterColor = GrColor_ILLEGAL;
1390 }
1391
1392 //============================================================================
1393 // Stage code generation
1394 //============================================================================
1395
1396 namespace {
1397
isRadialMapping(GrGLProgram::StageDesc::CoordMapping mapping)1398 bool isRadialMapping(GrGLProgram::StageDesc::CoordMapping mapping) {
1399 return
1400 (GrGLProgram::StageDesc::kRadial2Gradient_CoordMapping == mapping ||
1401 GrGLProgram::StageDesc::kRadial2GradientDegenerate_CoordMapping == mapping);
1402 }
1403
genRadialVS(int stageNum,ShaderCodeSegments * segments,GrGLProgram::StageUniLocations * locations,const char ** radial2VaryingVSName,const char ** radial2VaryingFSName,const char * varyingVSName,int varyingDims,int coordDims)1404 GrGLShaderVar* genRadialVS(int stageNum,
1405 ShaderCodeSegments* segments,
1406 GrGLProgram::StageUniLocations* locations,
1407 const char** radial2VaryingVSName,
1408 const char** radial2VaryingFSName,
1409 const char* varyingVSName,
1410 int varyingDims, int coordDims) {
1411
1412 GrGLShaderVar* radial2FSParams = &segments->fFSUnis.push_back();
1413 radial2FSParams->setType(GrGLShaderVar::kFloat_Type);
1414 radial2FSParams->setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
1415 radial2FSParams->setArrayCount(6);
1416 radial2_param_name(stageNum, radial2FSParams->accessName());
1417 segments->fVSUnis.push_back(*radial2FSParams).setEmitPrecision(true);
1418
1419 locations->fRadial2Uni = kUseUniform;
1420
1421 // for radial grads without perspective we can pass the linear
1422 // part of the quadratic as a varying.
1423 if (varyingDims == coordDims) {
1424 GrAssert(2 == coordDims);
1425 append_varying(GrGLShaderVar::kFloat_Type,
1426 "Radial2BCoeff",
1427 stageNum,
1428 segments,
1429 radial2VaryingVSName,
1430 radial2VaryingFSName);
1431
1432 GrStringBuilder radial2p2;
1433 GrStringBuilder radial2p3;
1434 radial2FSParams->appendArrayAccess(2, &radial2p2);
1435 radial2FSParams->appendArrayAccess(3, &radial2p3);
1436
1437 // r2Var = 2 * (r2Parm[2] * varCoord.x - r2Param[3])
1438 const char* r2ParamName = radial2FSParams->getName().c_str();
1439 segments->fVSCode.appendf("\t%s = 2.0 *(%s * %s.x - %s);\n",
1440 *radial2VaryingVSName, radial2p2.c_str(),
1441 varyingVSName, radial2p3.c_str());
1442 }
1443
1444 return radial2FSParams;
1445 }
1446
genRadial2GradientCoordMapping(int stageNum,ShaderCodeSegments * segments,const char * radial2VaryingFSName,GrGLShaderVar * radial2Params,GrStringBuilder & sampleCoords,GrStringBuilder & fsCoordName,int varyingDims,int coordDims)1447 bool genRadial2GradientCoordMapping(int stageNum,
1448 ShaderCodeSegments* segments,
1449 const char* radial2VaryingFSName,
1450 GrGLShaderVar* radial2Params,
1451 GrStringBuilder& sampleCoords,
1452 GrStringBuilder& fsCoordName,
1453 int varyingDims,
1454 int coordDims) {
1455 GrStringBuilder cName("c");
1456 GrStringBuilder ac4Name("ac4");
1457 GrStringBuilder rootName("root");
1458
1459 cName.appendS32(stageNum);
1460 ac4Name.appendS32(stageNum);
1461 rootName.appendS32(stageNum);
1462
1463 GrStringBuilder radial2p0;
1464 GrStringBuilder radial2p1;
1465 GrStringBuilder radial2p2;
1466 GrStringBuilder radial2p3;
1467 GrStringBuilder radial2p4;
1468 GrStringBuilder radial2p5;
1469 radial2Params->appendArrayAccess(0, &radial2p0);
1470 radial2Params->appendArrayAccess(1, &radial2p1);
1471 radial2Params->appendArrayAccess(2, &radial2p2);
1472 radial2Params->appendArrayAccess(3, &radial2p3);
1473 radial2Params->appendArrayAccess(4, &radial2p4);
1474 radial2Params->appendArrayAccess(5, &radial2p5);
1475
1476 // if we were able to interpolate the linear component bVar is the varying
1477 // otherwise compute it
1478 GrStringBuilder bVar;
1479 if (coordDims == varyingDims) {
1480 bVar = radial2VaryingFSName;
1481 GrAssert(2 == varyingDims);
1482 } else {
1483 GrAssert(3 == varyingDims);
1484 bVar = "b";
1485 bVar.appendS32(stageNum);
1486 segments->fFSCode.appendf("\tfloat %s = 2.0 * (%s * %s.x - %s);\n",
1487 bVar.c_str(), radial2p2.c_str(),
1488 fsCoordName.c_str(), radial2p3.c_str());
1489 }
1490
1491 // c = (x^2)+(y^2) - params[4]
1492 segments->fFSCode.appendf("\tfloat %s = dot(%s, %s) - %s;\n",
1493 cName.c_str(), fsCoordName.c_str(),
1494 fsCoordName.c_str(),
1495 radial2p4.c_str());
1496 // ac4 = 4.0 * params[0] * c
1497 segments->fFSCode.appendf("\tfloat %s = %s * 4.0 * %s;\n",
1498 ac4Name.c_str(), radial2p0.c_str(),
1499 cName.c_str());
1500
1501 // root = sqrt(b^2-4ac)
1502 // (abs to avoid exception due to fp precision)
1503 segments->fFSCode.appendf("\tfloat %s = sqrt(abs(%s*%s - %s));\n",
1504 rootName.c_str(), bVar.c_str(), bVar.c_str(),
1505 ac4Name.c_str());
1506
1507 // x coord is: (-b + params[5] * sqrt(b^2-4ac)) * params[1]
1508 // y coord is 0.5 (texture is effectively 1D)
1509 sampleCoords.printf("vec2((-%s + %s * %s) * %s, 0.5)",
1510 bVar.c_str(), radial2p5.c_str(),
1511 rootName.c_str(), radial2p1.c_str());
1512 return true;
1513 }
1514
genRadial2GradientDegenerateCoordMapping(int stageNum,ShaderCodeSegments * segments,const char * radial2VaryingFSName,GrGLShaderVar * radial2Params,GrStringBuilder & sampleCoords,GrStringBuilder & fsCoordName,int varyingDims,int coordDims)1515 bool genRadial2GradientDegenerateCoordMapping(int stageNum,
1516 ShaderCodeSegments* segments,
1517 const char* radial2VaryingFSName,
1518 GrGLShaderVar* radial2Params,
1519 GrStringBuilder& sampleCoords,
1520 GrStringBuilder& fsCoordName,
1521 int varyingDims,
1522 int coordDims) {
1523 GrStringBuilder cName("c");
1524
1525 cName.appendS32(stageNum);
1526
1527 GrStringBuilder radial2p2;
1528 GrStringBuilder radial2p3;
1529 GrStringBuilder radial2p4;
1530 radial2Params->appendArrayAccess(2, &radial2p2);
1531 radial2Params->appendArrayAccess(3, &radial2p3);
1532 radial2Params->appendArrayAccess(4, &radial2p4);
1533
1534 // if we were able to interpolate the linear component bVar is the varying
1535 // otherwise compute it
1536 GrStringBuilder bVar;
1537 if (coordDims == varyingDims) {
1538 bVar = radial2VaryingFSName;
1539 GrAssert(2 == varyingDims);
1540 } else {
1541 GrAssert(3 == varyingDims);
1542 bVar = "b";
1543 bVar.appendS32(stageNum);
1544 segments->fFSCode.appendf("\tfloat %s = 2.0 * (%s * %s.x - %s);\n",
1545 bVar.c_str(), radial2p2.c_str(),
1546 fsCoordName.c_str(), radial2p3.c_str());
1547 }
1548
1549 // c = (x^2)+(y^2) - params[4]
1550 segments->fFSCode.appendf("\tfloat %s = dot(%s, %s) - %s;\n",
1551 cName.c_str(), fsCoordName.c_str(),
1552 fsCoordName.c_str(),
1553 radial2p4.c_str());
1554
1555 // x coord is: -c/b
1556 // y coord is 0.5 (texture is effectively 1D)
1557 sampleCoords.printf("vec2((-%s / %s), 0.5)", cName.c_str(), bVar.c_str());
1558 return true;
1559 }
1560
gen2x2FS(int stageNum,ShaderCodeSegments * segments,GrGLProgram::StageUniLocations * locations,GrStringBuilder * sampleCoords,const char * samplerName,const char * texelSizeName,const char * swizzle,const char * fsOutColor,GrStringBuilder & texFunc,GrStringBuilder & modulate,bool complexCoord,int coordDims)1561 void gen2x2FS(int stageNum,
1562 ShaderCodeSegments* segments,
1563 GrGLProgram::StageUniLocations* locations,
1564 GrStringBuilder* sampleCoords,
1565 const char* samplerName,
1566 const char* texelSizeName,
1567 const char* swizzle,
1568 const char* fsOutColor,
1569 GrStringBuilder& texFunc,
1570 GrStringBuilder& modulate,
1571 bool complexCoord,
1572 int coordDims) {
1573 locations->fNormalizedTexelSizeUni = kUseUniform;
1574 if (complexCoord) {
1575 // assign the coord to a var rather than compute 4x.
1576 GrStringBuilder coordVar("tCoord");
1577 coordVar.appendS32(stageNum);
1578 segments->fFSCode.appendf("\t%s %s = %s;\n",
1579 float_vector_type_str(coordDims),
1580 coordVar.c_str(), sampleCoords->c_str());
1581 *sampleCoords = coordVar;
1582 }
1583 GrAssert(2 == coordDims);
1584 GrStringBuilder accumVar("accum");
1585 accumVar.appendS32(stageNum);
1586 segments->fFSCode.appendf("\tvec4 %s = %s(%s, %s + vec2(-%s.x,-%s.y))%s;\n", accumVar.c_str(), texFunc.c_str(), samplerName, sampleCoords->c_str(), texelSizeName, texelSizeName, swizzle);
1587 segments->fFSCode.appendf("\t%s += %s(%s, %s + vec2(+%s.x,-%s.y))%s;\n", accumVar.c_str(), texFunc.c_str(), samplerName, sampleCoords->c_str(), texelSizeName, texelSizeName, swizzle);
1588 segments->fFSCode.appendf("\t%s += %s(%s, %s + vec2(-%s.x,+%s.y))%s;\n", accumVar.c_str(), texFunc.c_str(), samplerName, sampleCoords->c_str(), texelSizeName, texelSizeName, swizzle);
1589 segments->fFSCode.appendf("\t%s += %s(%s, %s + vec2(+%s.x,+%s.y))%s;\n", accumVar.c_str(), texFunc.c_str(), samplerName, sampleCoords->c_str(), texelSizeName, texelSizeName, swizzle);
1590 segments->fFSCode.appendf("\t%s = .25 * %s%s;\n", fsOutColor, accumVar.c_str(), modulate.c_str());
1591
1592 }
1593
genConvolutionVS(int stageNum,const StageDesc & desc,ShaderCodeSegments * segments,GrGLProgram::StageUniLocations * locations,GrGLShaderVar ** kernel,const char ** imageIncrementName,const char * varyingVSName)1594 void genConvolutionVS(int stageNum,
1595 const StageDesc& desc,
1596 ShaderCodeSegments* segments,
1597 GrGLProgram::StageUniLocations* locations,
1598 GrGLShaderVar** kernel,
1599 const char** imageIncrementName,
1600 const char* varyingVSName) {
1601 //GrGLShaderVar* kernel = &segments->fFSUnis.push_back();
1602 *kernel = &segments->fFSUnis.push_back();
1603 (*kernel)->setType(GrGLShaderVar::kFloat_Type);
1604 (*kernel)->setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
1605 (*kernel)->setArrayCount(desc.fKernelWidth);
1606 GrGLShaderVar* imgInc = &segments->fFSUnis.push_back();
1607 imgInc->setType(GrGLShaderVar::kVec2f_Type);
1608 imgInc->setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
1609
1610 convolve_param_names(stageNum,
1611 (*kernel)->accessName(),
1612 imgInc->accessName());
1613 *imageIncrementName = imgInc->getName().c_str();
1614
1615 // need image increment in both VS and FS
1616 segments->fVSUnis.push_back(*imgInc).setEmitPrecision(true);
1617
1618 locations->fKernelUni = kUseUniform;
1619 locations->fImageIncrementUni = kUseUniform;
1620 float scale = (desc.fKernelWidth - 1) * 0.5f;
1621 segments->fVSCode.appendf("\t%s -= vec2(%g, %g) * %s;\n",
1622 varyingVSName, scale, scale,
1623 *imageIncrementName);
1624 }
1625
genConvolutionFS(int stageNum,const StageDesc & desc,ShaderCodeSegments * segments,const char * samplerName,GrGLShaderVar * kernel,const char * swizzle,const char * imageIncrementName,const char * fsOutColor,GrStringBuilder & sampleCoords,GrStringBuilder & texFunc,GrStringBuilder & modulate)1626 void genConvolutionFS(int stageNum,
1627 const StageDesc& desc,
1628 ShaderCodeSegments* segments,
1629 const char* samplerName,
1630 GrGLShaderVar* kernel,
1631 const char* swizzle,
1632 const char* imageIncrementName,
1633 const char* fsOutColor,
1634 GrStringBuilder& sampleCoords,
1635 GrStringBuilder& texFunc,
1636 GrStringBuilder& modulate) {
1637 GrStringBuilder sumVar("sum");
1638 sumVar.appendS32(stageNum);
1639 GrStringBuilder coordVar("coord");
1640 coordVar.appendS32(stageNum);
1641
1642 GrStringBuilder kernelIndex;
1643 kernel->appendArrayAccess("i", &kernelIndex);
1644
1645 segments->fFSCode.appendf("\tvec4 %s = vec4(0, 0, 0, 0);\n",
1646 sumVar.c_str());
1647 segments->fFSCode.appendf("\tvec2 %s = %s;\n",
1648 coordVar.c_str(),
1649 sampleCoords.c_str());
1650 segments->fFSCode.appendf("\tfor (int i = 0; i < %d; i++) {\n",
1651 desc.fKernelWidth);
1652 segments->fFSCode.appendf("\t\t%s += %s(%s, %s)%s * %s;\n",
1653 sumVar.c_str(), texFunc.c_str(),
1654 samplerName, coordVar.c_str(), swizzle,
1655 kernelIndex.c_str());
1656 segments->fFSCode.appendf("\t\t%s += %s;\n",
1657 coordVar.c_str(),
1658 imageIncrementName);
1659 segments->fFSCode.append("\t}\n");
1660 segments->fFSCode.appendf("\t%s = %s%s;\n", fsOutColor,
1661 sumVar.c_str(), modulate.c_str());
1662 }
1663
genMorphologyVS(int stageNum,const StageDesc & desc,ShaderCodeSegments * segments,GrGLProgram::StageUniLocations * locations,const char ** imageIncrementName,const char * varyingVSName)1664 void genMorphologyVS(int stageNum,
1665 const StageDesc& desc,
1666 ShaderCodeSegments* segments,
1667 GrGLProgram::StageUniLocations* locations,
1668 const char** imageIncrementName,
1669 const char* varyingVSName) {
1670 GrGLShaderVar* imgInc = &segments->fFSUnis.push_back();
1671 imgInc->setType(GrGLShaderVar::kVec2f_Type);
1672 imgInc->setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
1673
1674 image_increment_param_name(stageNum, imgInc->accessName());
1675 *imageIncrementName = imgInc->getName().c_str();
1676
1677 // need image increment in both VS and FS
1678 segments->fVSUnis.push_back(*imgInc).setEmitPrecision(true);
1679
1680 locations->fImageIncrementUni = kUseUniform;
1681 segments->fVSCode.appendf("\t%s -= vec2(%d, %d) * %s;\n",
1682 varyingVSName, desc.fKernelWidth,
1683 desc.fKernelWidth, *imageIncrementName);
1684 }
1685
genMorphologyFS(int stageNum,const StageDesc & desc,ShaderCodeSegments * segments,const char * samplerName,const char * swizzle,const char * imageIncrementName,const char * fsOutColor,GrStringBuilder & sampleCoords,GrStringBuilder & texFunc,GrStringBuilder & modulate)1686 void genMorphologyFS(int stageNum,
1687 const StageDesc& desc,
1688 ShaderCodeSegments* segments,
1689 const char* samplerName,
1690 const char* swizzle,
1691 const char* imageIncrementName,
1692 const char* fsOutColor,
1693 GrStringBuilder& sampleCoords,
1694 GrStringBuilder& texFunc,
1695 GrStringBuilder& modulate) {
1696 GrStringBuilder valueVar("value");
1697 valueVar.appendS32(stageNum);
1698 GrStringBuilder coordVar("coord");
1699 coordVar.appendS32(stageNum);
1700 bool isDilate = StageDesc::kDilate_FetchMode == desc.fFetchMode;
1701
1702 if (isDilate) {
1703 segments->fFSCode.appendf("\tvec4 %s = vec4(0, 0, 0, 0);\n",
1704 valueVar.c_str());
1705 } else {
1706 segments->fFSCode.appendf("\tvec4 %s = vec4(1, 1, 1, 1);\n",
1707 valueVar.c_str());
1708 }
1709 segments->fFSCode.appendf("\tvec2 %s = %s;\n",
1710 coordVar.c_str(),
1711 sampleCoords.c_str());
1712 segments->fFSCode.appendf("\tfor (int i = 0; i < %d; i++) {\n",
1713 desc.fKernelWidth * 2 + 1);
1714 segments->fFSCode.appendf("\t\t%s = %s(%s, %s(%s, %s)%s);\n",
1715 valueVar.c_str(), isDilate ? "max" : "min",
1716 valueVar.c_str(), texFunc.c_str(),
1717 samplerName, coordVar.c_str(), swizzle);
1718 segments->fFSCode.appendf("\t\t%s += %s;\n",
1719 coordVar.c_str(),
1720 imageIncrementName);
1721 segments->fFSCode.appendf("\t}\n");
1722 segments->fFSCode.appendf("\t%s = %s%s;\n", fsOutColor,
1723 valueVar.c_str(), modulate.c_str());
1724 }
1725
1726 }
1727
genStageCode(const GrGLContextInfo & gl,int stageNum,const GrGLProgram::StageDesc & desc,const char * fsInColor,const char * fsOutColor,const char * vsInCoord,ShaderCodeSegments * segments,StageUniLocations * locations) const1728 void GrGLProgram::genStageCode(const GrGLContextInfo& gl,
1729 int stageNum,
1730 const GrGLProgram::StageDesc& desc,
1731 const char* fsInColor, // NULL means no incoming color
1732 const char* fsOutColor,
1733 const char* vsInCoord,
1734 ShaderCodeSegments* segments,
1735 StageUniLocations* locations) const {
1736
1737 GrAssert(stageNum >= 0 && stageNum <= GrDrawState::kNumStages);
1738 GrAssert((desc.fInConfigFlags & StageDesc::kInConfigBitMask) ==
1739 desc.fInConfigFlags);
1740
1741 // First decide how many coords are needed to access the texture
1742 // Right now it's always 2 but we could start using 1D textures for
1743 // gradients.
1744 static const int coordDims = 2;
1745 int varyingDims;
1746 /// Vertex Shader Stuff
1747
1748 // decide whether we need a matrix to transform texture coords
1749 // and whether the varying needs a perspective coord.
1750 const char* matName = NULL;
1751 if (desc.fOptFlags & StageDesc::kIdentityMatrix_OptFlagBit) {
1752 varyingDims = coordDims;
1753 } else {
1754 GrGLShaderVar* mat;
1755 #if GR_GL_ATTRIBUTE_MATRICES
1756 mat = &segments->fVSAttrs.push_back();
1757 mat->setTypeModifier(GrGLShaderVar::kAttribute_TypeModifier);
1758 locations->fTextureMatrixUni = kSetAsAttribute;
1759 #else
1760 mat = &segments->fVSUnis.push_back();
1761 mat->setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
1762 locations->fTextureMatrixUni = kUseUniform;
1763 #endif
1764 tex_matrix_name(stageNum, mat->accessName());
1765 mat->setType(GrGLShaderVar::kMat33f_Type);
1766 matName = mat->getName().c_str();
1767
1768 if (desc.fOptFlags & StageDesc::kNoPerspective_OptFlagBit) {
1769 varyingDims = coordDims;
1770 } else {
1771 varyingDims = coordDims + 1;
1772 }
1773 }
1774
1775 segments->fFSUnis.push_back().set(GrGLShaderVar::kSampler2D_Type,
1776 GrGLShaderVar::kUniform_TypeModifier, "");
1777 sampler_name(stageNum, segments->fFSUnis.back().accessName());
1778 locations->fSamplerUni = kUseUniform;
1779 const char* samplerName = segments->fFSUnis.back().getName().c_str();
1780
1781 const char* texelSizeName = NULL;
1782 if (StageDesc::k2x2_FetchMode == desc.fFetchMode) {
1783 segments->fFSUnis.push_back().set(GrGLShaderVar::kVec2f_Type,
1784 GrGLShaderVar::kUniform_TypeModifier, "");
1785 normalized_texel_size_name(stageNum, segments->fFSUnis.back().accessName());
1786 texelSizeName = segments->fFSUnis.back().getName().c_str();
1787 }
1788
1789 const char *varyingVSName, *varyingFSName;
1790 append_varying(float_vector_type(varyingDims),
1791 "Stage",
1792 stageNum,
1793 segments,
1794 &varyingVSName,
1795 &varyingFSName);
1796
1797 if (!matName) {
1798 GrAssert(varyingDims == coordDims);
1799 segments->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord);
1800 } else {
1801 // varying = texMatrix * texCoord
1802 segments->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n",
1803 varyingVSName, matName, vsInCoord,
1804 vector_all_coords(varyingDims));
1805 }
1806
1807 GrGLShaderVar* radial2Params = NULL;
1808 const char* radial2VaryingVSName = NULL;
1809 const char* radial2VaryingFSName = NULL;
1810
1811 if (isRadialMapping((StageDesc::CoordMapping) desc.fCoordMapping)) {
1812 radial2Params = genRadialVS(stageNum, segments,
1813 locations,
1814 &radial2VaryingVSName,
1815 &radial2VaryingFSName,
1816 varyingVSName,
1817 varyingDims, coordDims);
1818 }
1819
1820 GrGLShaderVar* kernel = NULL;
1821 const char* imageIncrementName = NULL;
1822 if (StageDesc::kConvolution_FetchMode == desc.fFetchMode) {
1823 genConvolutionVS(stageNum, desc, segments, locations,
1824 &kernel, &imageIncrementName, varyingVSName);
1825 } else if (StageDesc::kDilate_FetchMode == desc.fFetchMode ||
1826 StageDesc::kErode_FetchMode == desc.fFetchMode) {
1827 genMorphologyVS(stageNum, desc, segments, locations,
1828 &imageIncrementName, varyingVSName);
1829 }
1830
1831 /// Fragment Shader Stuff
1832 GrStringBuilder fsCoordName;
1833 // function used to access the shader, may be made projective
1834 GrStringBuilder texFunc("texture2D");
1835 if (desc.fOptFlags & (StageDesc::kIdentityMatrix_OptFlagBit |
1836 StageDesc::kNoPerspective_OptFlagBit)) {
1837 GrAssert(varyingDims == coordDims);
1838 fsCoordName = varyingFSName;
1839 } else {
1840 // if we have to do some special op on the varyings to get
1841 // our final tex coords then when in perspective we have to
1842 // do an explicit divide. Otherwise, we can use a Proj func.
1843 if (StageDesc::kIdentity_CoordMapping == desc.fCoordMapping &&
1844 StageDesc::kSingle_FetchMode == desc.fFetchMode) {
1845 texFunc.append("Proj");
1846 fsCoordName = varyingFSName;
1847 } else {
1848 fsCoordName = "inCoord";
1849 fsCoordName.appendS32(stageNum);
1850 segments->fFSCode.appendf("\t%s %s = %s%s / %s%s;\n",
1851 GrGLShaderVar::TypeString(float_vector_type(coordDims)),
1852 fsCoordName.c_str(),
1853 varyingFSName,
1854 vector_nonhomog_coords(varyingDims),
1855 varyingFSName,
1856 vector_homog_coord(varyingDims));
1857 }
1858 }
1859
1860 GrStringBuilder sampleCoords;
1861 bool complexCoord = false;
1862 switch (desc.fCoordMapping) {
1863 case StageDesc::kIdentity_CoordMapping:
1864 sampleCoords = fsCoordName;
1865 break;
1866 case StageDesc::kSweepGradient_CoordMapping:
1867 sampleCoords.printf("vec2(atan(- %s.y, - %s.x) * 0.1591549430918 + 0.5, 0.5)", fsCoordName.c_str(), fsCoordName.c_str());
1868 complexCoord = true;
1869 break;
1870 case StageDesc::kRadialGradient_CoordMapping:
1871 sampleCoords.printf("vec2(length(%s.xy), 0.5)", fsCoordName.c_str());
1872 complexCoord = true;
1873 break;
1874 case StageDesc::kRadial2Gradient_CoordMapping:
1875 complexCoord = genRadial2GradientCoordMapping(
1876 stageNum, segments,
1877 radial2VaryingFSName, radial2Params,
1878 sampleCoords, fsCoordName,
1879 varyingDims, coordDims);
1880
1881 break;
1882 case StageDesc::kRadial2GradientDegenerate_CoordMapping:
1883 complexCoord = genRadial2GradientDegenerateCoordMapping(
1884 stageNum, segments,
1885 radial2VaryingFSName, radial2Params,
1886 sampleCoords, fsCoordName,
1887 varyingDims, coordDims);
1888 break;
1889
1890 };
1891
1892 static const uint32_t kMulByAlphaMask =
1893 (StageDesc::kMulRGBByAlpha_RoundUp_InConfigFlag |
1894 StageDesc::kMulRGBByAlpha_RoundDown_InConfigFlag);
1895
1896 const char* swizzle = "";
1897 if (desc.fInConfigFlags & StageDesc::kSwapRAndB_InConfigFlag) {
1898 GrAssert(!(desc.fInConfigFlags & StageDesc::kSmearAlpha_InConfigFlag));
1899 swizzle = ".bgra";
1900 } else if (desc.fInConfigFlags & StageDesc::kSmearAlpha_InConfigFlag) {
1901 GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
1902 swizzle = ".aaaa";
1903 }
1904
1905 GrStringBuilder modulate;
1906 if (NULL != fsInColor) {
1907 modulate.printf(" * %s", fsInColor);
1908 }
1909
1910 if (desc.fOptFlags &
1911 StageDesc::kCustomTextureDomain_OptFlagBit) {
1912 GrStringBuilder texDomainName;
1913 tex_domain_name(stageNum, &texDomainName);
1914 segments->fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
1915 GrGLShaderVar::kUniform_TypeModifier, texDomainName);
1916 GrStringBuilder coordVar("clampCoord");
1917 segments->fFSCode.appendf("\t%s %s = clamp(%s, %s.xy, %s.zw);\n",
1918 float_vector_type_str(coordDims),
1919 coordVar.c_str(),
1920 sampleCoords.c_str(),
1921 texDomainName.c_str(),
1922 texDomainName.c_str());
1923 sampleCoords = coordVar;
1924 locations->fTexDomUni = kUseUniform;
1925 }
1926
1927 switch (desc.fFetchMode) {
1928 case StageDesc::k2x2_FetchMode:
1929 GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
1930 gen2x2FS(stageNum, segments, locations, &sampleCoords,
1931 samplerName, texelSizeName, swizzle, fsOutColor,
1932 texFunc, modulate, complexCoord, coordDims);
1933 break;
1934 case StageDesc::kConvolution_FetchMode:
1935 GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
1936 genConvolutionFS(stageNum, desc, segments,
1937 samplerName, kernel, swizzle, imageIncrementName, fsOutColor,
1938 sampleCoords, texFunc, modulate);
1939 break;
1940 case StageDesc::kDilate_FetchMode:
1941 case StageDesc::kErode_FetchMode:
1942 GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
1943 genMorphologyFS(stageNum, desc, segments,
1944 samplerName, swizzle, imageIncrementName, fsOutColor,
1945 sampleCoords, texFunc, modulate);
1946 break;
1947 default:
1948 if (desc.fInConfigFlags & kMulByAlphaMask) {
1949 // only one of the mul by alpha flags should be set
1950 GrAssert(GrIsPow2(kMulByAlphaMask & desc.fInConfigFlags));
1951 GrAssert(!(desc.fInConfigFlags &
1952 StageDesc::kSmearAlpha_InConfigFlag));
1953 segments->fFSCode.appendf("\t%s = %s(%s, %s)%s;\n",
1954 fsOutColor, texFunc.c_str(),
1955 samplerName, sampleCoords.c_str(),
1956 swizzle);
1957 if (desc.fInConfigFlags &
1958 StageDesc::kMulRGBByAlpha_RoundUp_InConfigFlag) {
1959 segments->fFSCode.appendf("\t%s = vec4(ceil(%s.rgb*%s.a*255.0)/255.0,%s.a)%s;\n",
1960 fsOutColor, fsOutColor, fsOutColor,
1961 fsOutColor, modulate.c_str());
1962 } else {
1963 segments->fFSCode.appendf("\t%s = vec4(floor(%s.rgb*%s.a*255.0)/255.0,%s.a)%s;\n",
1964 fsOutColor, fsOutColor, fsOutColor,
1965 fsOutColor, modulate.c_str());
1966 }
1967 } else {
1968 segments->fFSCode.appendf("\t%s = %s(%s, %s)%s%s;\n",
1969 fsOutColor, texFunc.c_str(),
1970 samplerName, sampleCoords.c_str(),
1971 swizzle, modulate.c_str());
1972 }
1973 }
1974 }
1975
1976
1977