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