blob: e817c1afc39c3d6f556e6b68b4740e831027b2d0 [file] [log] [blame]
junov@google.comf93e7172011-03-31 21:26:24 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
junov@google.comf93e7172011-03-31 21:26:24 +00006 */
7
8#include "GrGLProgram.h"
9
tomhudson@google.comd8f856c2012-05-10 12:13:36 +000010#include "GrAllocator.h"
bsalomon@google.coma469c282012-10-24 18:28:34 +000011#include "GrEffect.h"
bsalomon@google.comd698f772012-10-25 13:22:00 +000012#include "GrGLEffect.h"
tomhudson@google.comf9ad8862012-05-11 20:38:48 +000013#include "gl/GrGLShaderBuilder.h"
bsalomon@google.com4fa66942011-09-20 19:06:12 +000014#include "GrGLShaderVar.h"
tomhudson@google.comd8f856c2012-05-10 12:13:36 +000015#include "GrProgramStageFactory.h"
tomhudson@google.com0c8d93a2011-07-01 17:08:26 +000016#include "SkTrace.h"
Scroggo97c88c22011-05-11 14:05:25 +000017#include "SkXfermode.h"
18
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +000019SK_DEFINE_INST_COUNT(GrGLProgram)
20
bsalomon@google.comecb60aa2012-07-18 13:20:29 +000021#define GL_CALL(X) GR_GL_CALL(fContextInfo.interface(), X)
22#define GL_CALL_RET(R, X) GR_GL_CALL_RET(fContextInfo.interface(), R, X)
23
rileya@google.come38160c2012-07-03 18:03:04 +000024#define PRINT_SHADERS 0
bsalomon@google.com6aef1fb2011-05-05 12:33:22 +000025
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +000026typedef GrGLProgram::Desc::StageDesc StageDesc;
bsalomon@google.com4fa66942011-09-20 19:06:12 +000027
junov@google.comf93e7172011-03-31 21:26:24 +000028#define POS_ATTR_NAME "aPosition"
29#define COL_ATTR_NAME "aColor"
bsalomon@google.coma3108262011-10-10 14:08:47 +000030#define COV_ATTR_NAME "aCoverage"
bsalomon@google.comaeb21602011-08-30 18:13:44 +000031#define EDGE_ATTR_NAME "aEdge"
junov@google.comf93e7172011-03-31 21:26:24 +000032
bsalomon@google.com4fa66942011-09-20 19:06:12 +000033namespace {
bsalomon@google.comf0a104e2012-07-10 17:51:07 +000034inline void tex_attr_name(int coordIdx, SkString* s) {
junov@google.comf93e7172011-03-31 21:26:24 +000035 *s = "aTexCoord";
bsalomon@google.comfc296292011-05-06 13:53:47 +000036 s->appendS32(coordIdx);
junov@google.comf93e7172011-03-31 21:26:24 +000037}
38
bsalomon@google.com4fa66942011-09-20 19:06:12 +000039inline const char* float_vector_type_str(int count) {
tomhudson@google.com168e6342012-04-18 17:49:20 +000040 return GrGLShaderVar::TypeString(GrSLFloatVectorType(count));
junov@google.comf93e7172011-03-31 21:26:24 +000041}
42
bsalomon@google.com4fa66942011-09-20 19:06:12 +000043inline const char* vector_all_coords(int count) {
junov@google.comf93e7172011-03-31 21:26:24 +000044 static const char* ALL[] = {"ERROR", "", ".xy", ".xyz", ".xyzw"};
45 GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(ALL));
46 return ALL[count];
47}
48
bsalomon@google.com4fa66942011-09-20 19:06:12 +000049inline const char* declared_color_output_name() { return "fsColorOut"; }
50inline const char* dual_source_output_name() { return "dualSourceOut"; }
bsalomon@google.com271cffc2011-05-20 14:13:56 +000051
bsalomon@google.com4fa66942011-09-20 19:06:12 +000052}
junov@google.com6acc9b32011-05-16 18:32:07 +000053
bsalomon@google.comecb60aa2012-07-18 13:20:29 +000054GrGLProgram* GrGLProgram::Create(const GrGLContextInfo& gl,
55 const Desc& desc,
bsalomon@google.comf271cc72012-10-24 19:35:13 +000056 const GrEffect** effects) {
57 GrGLProgram* program = SkNEW_ARGS(GrGLProgram, (gl, desc, effects));
bsalomon@google.comecb60aa2012-07-18 13:20:29 +000058 if (!program->succeeded()) {
59 delete program;
60 program = NULL;
61 }
62 return program;
63}
64
65GrGLProgram::GrGLProgram(const GrGLContextInfo& gl,
66 const Desc& desc,
bsalomon@google.comf271cc72012-10-24 19:35:13 +000067 const GrEffect** effects)
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000068: fContextInfo(gl)
69, fUniformManager(gl) {
bsalomon@google.comecb60aa2012-07-18 13:20:29 +000070 fDesc = desc;
71 fVShaderID = 0;
72 fGShaderID = 0;
73 fFShaderID = 0;
74 fProgramID = 0;
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000075
76 fViewMatrix = GrMatrix::InvalidMatrix();
77 fViewportSize.set(-1, -1);
78 fColor = GrColor_ILLEGAL;
79 fColorFilterColor = GrColor_ILLEGAL;
bsalomon@google.com706f6682012-10-23 14:53:55 +000080 fRTHeight = -1;
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000081
bsalomon@google.comecb60aa2012-07-18 13:20:29 +000082 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
83 fProgramStage[s] = NULL;
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000084 fTextureMatrices[s] = GrMatrix::InvalidMatrix();
85 // this is arbitrary, just initialize to something
86 fTextureOrientation[s] = GrGLTexture::kBottomUp_Orientation;
bsalomon@google.comecb60aa2012-07-18 13:20:29 +000087 }
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000088
bsalomon@google.comf271cc72012-10-24 19:35:13 +000089 this->genProgram(effects);
junov@google.comf93e7172011-03-31 21:26:24 +000090}
91
92GrGLProgram::~GrGLProgram() {
bsalomon@google.comecb60aa2012-07-18 13:20:29 +000093 if (fVShaderID) {
94 GL_CALL(DeleteShader(fVShaderID));
95 }
96 if (fGShaderID) {
97 GL_CALL(DeleteShader(fGShaderID));
98 }
99 if (fFShaderID) {
100 GL_CALL(DeleteShader(fFShaderID));
101 }
102 if (fProgramID) {
103 GL_CALL(DeleteProgram(fProgramID));
104 }
105
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000106 for (int i = 0; i < GrDrawState::kNumStages; ++i) {
107 delete fProgramStage[i];
108 }
junov@google.comf93e7172011-03-31 21:26:24 +0000109}
110
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000111void GrGLProgram::abandon() {
112 fVShaderID = 0;
113 fGShaderID = 0;
114 fFShaderID = 0;
115 fProgramID = 0;
116}
117
tomhudson@google.com0d3f1fb2011-06-01 19:27:31 +0000118void GrGLProgram::overrideBlend(GrBlendCoeff* srcCoeff,
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000119 GrBlendCoeff* dstCoeff) const {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000120 switch (fDesc.fDualSrcOutput) {
121 case Desc::kNone_DualSrcOutput:
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000122 break;
123 // the prog will write a coverage value to the secondary
124 // output and the dst is blended by one minus that value.
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000125 case Desc::kCoverage_DualSrcOutput:
126 case Desc::kCoverageISA_DualSrcOutput:
127 case Desc::kCoverageISC_DualSrcOutput:
bsalomon@google.com47059542012-06-06 20:51:20 +0000128 *dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000129 break;
130 default:
131 GrCrash("Unexpected dual source blend output");
132 break;
133 }
134}
135
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000136// given two blend coeffecients determine whether the src
137// and/or dst computation can be omitted.
138static inline void needBlendInputs(SkXfermode::Coeff srcCoeff,
139 SkXfermode::Coeff dstCoeff,
140 bool* needSrcValue,
141 bool* needDstValue) {
142 if (SkXfermode::kZero_Coeff == srcCoeff) {
143 switch (dstCoeff) {
144 // these all read the src
145 case SkXfermode::kSC_Coeff:
146 case SkXfermode::kISC_Coeff:
147 case SkXfermode::kSA_Coeff:
148 case SkXfermode::kISA_Coeff:
149 *needSrcValue = true;
150 break;
151 default:
152 *needSrcValue = false;
153 break;
154 }
155 } else {
156 *needSrcValue = true;
157 }
158 if (SkXfermode::kZero_Coeff == dstCoeff) {
159 switch (srcCoeff) {
160 // these all read the dst
161 case SkXfermode::kDC_Coeff:
162 case SkXfermode::kIDC_Coeff:
163 case SkXfermode::kDA_Coeff:
164 case SkXfermode::kIDA_Coeff:
165 *needDstValue = true;
166 break;
167 default:
168 *needDstValue = false;
169 break;
170 }
171 } else {
172 *needDstValue = true;
Scroggo97c88c22011-05-11 14:05:25 +0000173 }
174}
175
176/**
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000177 * Create a blend_coeff * value string to be used in shader code. Sets empty
178 * string if result is trivially zero.
179 */
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000180static void blendTermString(SkString* str, SkXfermode::Coeff coeff,
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000181 const char* src, const char* dst,
182 const char* value) {
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000183 switch (coeff) {
184 case SkXfermode::kZero_Coeff: /** 0 */
185 *str = "";
186 break;
187 case SkXfermode::kOne_Coeff: /** 1 */
188 *str = value;
189 break;
190 case SkXfermode::kSC_Coeff:
191 str->printf("(%s * %s)", src, value);
192 break;
193 case SkXfermode::kISC_Coeff:
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000194 str->printf("((%s - %s) * %s)", GrGLSLOnesVecf(4), src, value);
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000195 break;
196 case SkXfermode::kDC_Coeff:
197 str->printf("(%s * %s)", dst, value);
198 break;
199 case SkXfermode::kIDC_Coeff:
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000200 str->printf("((%s - %s) * %s)", GrGLSLOnesVecf(4), dst, value);
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000201 break;
202 case SkXfermode::kSA_Coeff: /** src alpha */
203 str->printf("(%s.a * %s)", src, value);
204 break;
205 case SkXfermode::kISA_Coeff: /** inverse src alpha (i.e. 1 - sa) */
206 str->printf("((1.0 - %s.a) * %s)", src, value);
207 break;
208 case SkXfermode::kDA_Coeff: /** dst alpha */
209 str->printf("(%s.a * %s)", dst, value);
210 break;
211 case SkXfermode::kIDA_Coeff: /** inverse dst alpha (i.e. 1 - da) */
212 str->printf("((1.0 - %s.a) * %s)", dst, value);
213 break;
214 default:
215 GrCrash("Unexpected xfer coeff.");
216 break;
217 }
218}
219/**
Scroggo97c88c22011-05-11 14:05:25 +0000220 * Adds a line to the fragment shader code which modifies the color by
221 * the specified color filter.
222 */
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000223static void addColorFilter(SkString* fsCode, const char * outputVar,
tomhudson@google.com0d3f1fb2011-06-01 19:27:31 +0000224 SkXfermode::Coeff uniformCoeff,
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000225 SkXfermode::Coeff colorCoeff,
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000226 const char* filterColor,
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000227 const char* inColor) {
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000228 SkString colorStr, constStr;
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000229 blendTermString(&colorStr, colorCoeff, filterColor, inColor, inColor);
230 blendTermString(&constStr, uniformCoeff, filterColor, inColor, filterColor);
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000231
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000232 fsCode->appendf("\t%s = ", outputVar);
233 GrGLSLAdd4f(fsCode, colorStr.c_str(), constStr.c_str());
234 fsCode->append(";\n");
Scroggo97c88c22011-05-11 14:05:25 +0000235}
236
bsalomon@google.comd4726202012-08-03 14:34:46 +0000237bool GrGLProgram::genEdgeCoverage(SkString* coverageVar,
bsalomon@google.com706f6682012-10-23 14:53:55 +0000238 GrGLShaderBuilder* builder) const {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000239 if (fDesc.fVertexLayout & GrDrawTarget::kEdge_VertexLayoutBit) {
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000240 const char *vsName, *fsName;
bsalomon@google.com706f6682012-10-23 14:53:55 +0000241 builder->addVarying(kVec4f_GrSLType, "Edge", &vsName, &fsName);
242 builder->fVSAttrs.push_back().set(kVec4f_GrSLType,
243 GrGLShaderVar::kAttribute_TypeModifier,
244 EDGE_ATTR_NAME);
245 builder->fVSCode.appendf("\t%s = " EDGE_ATTR_NAME ";\n", vsName);
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000246 switch (fDesc.fVertexEdgeType) {
bsalomon@google.com93c96602012-04-27 13:05:21 +0000247 case GrDrawState::kHairLine_EdgeType:
bsalomon@google.com706f6682012-10-23 14:53:55 +0000248 builder->fFSCode.appendf("\tfloat edgeAlpha = abs(dot(vec3(%s.xy,1), %s.xyz));\n", builder->fragmentPosition(), fsName);
249 builder->fFSCode.append("\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
bsalomon@google.com93c96602012-04-27 13:05:21 +0000250 break;
251 case GrDrawState::kQuad_EdgeType:
bsalomon@google.com706f6682012-10-23 14:53:55 +0000252 builder->fFSCode.append("\tfloat edgeAlpha;\n");
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000253 // keep the derivative instructions outside the conditional
bsalomon@google.com706f6682012-10-23 14:53:55 +0000254 builder->fFSCode.appendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
255 builder->fFSCode.appendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
256 builder->fFSCode.appendf("\tif (%s.z > 0.0 && %s.w > 0.0) {\n", fsName, fsName);
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000257 // today we know z and w are in device space. We could use derivatives
bsalomon@google.com706f6682012-10-23 14:53:55 +0000258 builder->fFSCode.appendf("\t\tedgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);\n", fsName, fsName);
259 builder->fFSCode.append ("\t} else {\n");
260 builder->fFSCode.appendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
261 "\t\t 2.0*%s.x*duvdy.x - duvdy.y);\n",
262 fsName, fsName);
263 builder->fFSCode.appendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
264 builder->fFSCode.append("\t\tedgeAlpha = clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);\n"
265 "\t}\n");
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000266 if (kES2_GrGLBinding == fContextInfo.binding()) {
bsalomon@google.com706f6682012-10-23 14:53:55 +0000267 builder->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000268 }
bsalomon@google.com93c96602012-04-27 13:05:21 +0000269 break;
270 case GrDrawState::kHairQuad_EdgeType:
bsalomon@google.com706f6682012-10-23 14:53:55 +0000271 builder->fFSCode.appendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
272 builder->fFSCode.appendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
273 builder->fFSCode.appendf("\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
274 "\t 2.0*%s.x*duvdy.x - duvdy.y);\n",
275 fsName, fsName);
276 builder->fFSCode.appendf("\tfloat edgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
277 builder->fFSCode.append("\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / dot(gF, gF));\n");
278 builder->fFSCode.append("\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000279 if (kES2_GrGLBinding == fContextInfo.binding()) {
bsalomon@google.com706f6682012-10-23 14:53:55 +0000280 builder->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
bsalomon@google.com66105672011-09-15 15:12:00 +0000281 }
bsalomon@google.com93c96602012-04-27 13:05:21 +0000282 break;
283 case GrDrawState::kCircle_EdgeType:
bsalomon@google.com706f6682012-10-23 14:53:55 +0000284 builder->fFSCode.append("\tfloat edgeAlpha;\n");
285 builder->fFSCode.appendf("\tfloat d = distance(%s.xy, %s.xy);\n", builder->fragmentPosition(), fsName);
286 builder->fFSCode.appendf("\tfloat outerAlpha = smoothstep(d - 0.5, d + 0.5, %s.z);\n", fsName);
287 builder->fFSCode.appendf("\tfloat innerAlpha = %s.w == 0.0 ? 1.0 : smoothstep(%s.w - 0.5, %s.w + 0.5, d);\n", fsName, fsName, fsName);
288 builder->fFSCode.append("\tedgeAlpha = outerAlpha * innerAlpha;\n");
bsalomon@google.com93c96602012-04-27 13:05:21 +0000289 break;
290 default:
291 GrCrash("Unknown Edge Type!");
292 break;
bsalomon@google.com66105672011-09-15 15:12:00 +0000293 }
bsalomon@google.com66105672011-09-15 15:12:00 +0000294 *coverageVar = "edgeAlpha";
bsalomon@google.comd4726202012-08-03 14:34:46 +0000295 return true;
bsalomon@google.com66105672011-09-15 15:12:00 +0000296 } else {
297 coverageVar->reset();
bsalomon@google.comd4726202012-08-03 14:34:46 +0000298 return false;
bsalomon@google.com66105672011-09-15 15:12:00 +0000299 }
300}
301
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000302void GrGLProgram::genInputColor(GrGLShaderBuilder* builder, SkString* inColor) {
303 switch (fDesc.fColorInput) {
304 case GrGLProgram::Desc::kAttribute_ColorInput: {
305 builder->fVSAttrs.push_back().set(kVec4f_GrSLType,
tomhudson@google.com086e5352011-12-08 14:44:10 +0000306 GrGLShaderVar::kAttribute_TypeModifier,
307 COL_ATTR_NAME);
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000308 const char *vsName, *fsName;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000309 builder->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
310 builder->fVSCode.appendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000311 *inColor = fsName;
312 } break;
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000313 case GrGLProgram::Desc::kUniform_ColorInput: {
314 const char* name;
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000315 fUniforms.fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000316 kVec4f_GrSLType, "Color", &name);
317 *inColor = name;
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000318 break;
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000319 }
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000320 case GrGLProgram::Desc::kTransBlack_ColorInput:
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000321 GrAssert(!"needComputedColor should be false.");
322 break;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000323 case GrGLProgram::Desc::kSolidWhite_ColorInput:
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000324 break;
325 default:
326 GrCrash("Unknown color type.");
327 break;
328 }
329}
330
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000331void GrGLProgram::genUniformCoverage(GrGLShaderBuilder* builder, SkString* inOutCoverage) {
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000332 const char* covUniName;
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000333 fUniforms.fCoverageUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000334 kVec4f_GrSLType, "Coverage", &covUniName);
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000335 if (inOutCoverage->size()) {
336 builder->fFSCode.appendf("\tvec4 uniCoverage = %s * %s;\n",
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000337 covUniName, inOutCoverage->c_str());
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000338 *inOutCoverage = "uniCoverage";
339 } else {
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000340 *inOutCoverage = covUniName;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000341 }
342}
343
344namespace {
345void gen_attribute_coverage(GrGLShaderBuilder* segments,
346 SkString* inOutCoverage) {
tomhudson@google.com168e6342012-04-18 17:49:20 +0000347 segments->fVSAttrs.push_back().set(kVec4f_GrSLType,
tomhudson@google.com086e5352011-12-08 14:44:10 +0000348 GrGLShaderVar::kAttribute_TypeModifier,
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000349 COV_ATTR_NAME);
350 const char *vsName, *fsName;
tomhudson@google.com23cb2292012-05-30 18:26:03 +0000351 segments->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000352 segments->fVSCode.appendf("\t%s = " COV_ATTR_NAME ";\n", vsName);
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000353 if (inOutCoverage->size()) {
354 segments->fFSCode.appendf("\tvec4 attrCoverage = %s * %s;\n",
355 fsName, inOutCoverage->c_str());
356 *inOutCoverage = "attrCoverage";
tomhudson@google.com2a2e3ef2011-10-25 19:51:09 +0000357 } else {
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000358 *inOutCoverage = fsName;
359 }
360}
bsalomon@google.com4fa66942011-09-20 19:06:12 +0000361}
362
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000363void GrGLProgram::genGeometryShader(GrGLShaderBuilder* segments) const {
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000364#if GR_GL_EXPERIMENTAL_GS
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000365 if (fDesc.fExperimentalGS) {
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000366 GrAssert(fContextInfo.glslGeneration() >= k150_GrGLSLGeneration);
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000367 segments->fGSHeader.append("layout(triangles) in;\n"
368 "layout(triangle_strip, max_vertices = 6) out;\n");
bsalomon@google.comd7bafb72012-10-22 14:30:50 +0000369 segments->fGSCode.append("\tfor (int i = 0; i < 3; ++i) {\n"
370 "\t\tgl_Position = gl_in[i].gl_Position;\n");
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000371 if (fDesc.fEmitsPointSize) {
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000372 segments->fGSCode.append("\t\tgl_PointSize = 1.0;\n");
373 }
374 GrAssert(segments->fGSInputs.count() == segments->fGSOutputs.count());
375 int count = segments->fGSInputs.count();
376 for (int i = 0; i < count; ++i) {
377 segments->fGSCode.appendf("\t\t%s = %s[i];\n",
378 segments->fGSOutputs[i].getName().c_str(),
379 segments->fGSInputs[i].getName().c_str());
380 }
381 segments->fGSCode.append("\t\tEmitVertex();\n"
382 "\t}\n"
bsalomon@google.comd7bafb72012-10-22 14:30:50 +0000383 "\tEndPrimitive();\n");
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000384 }
385#endif
386}
387
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000388const char* GrGLProgram::adjustInColor(const SkString& inColor) const {
senorblanco@chromium.orgb3a39b52012-01-05 18:28:56 +0000389 if (inColor.size()) {
390 return inColor.c_str();
391 } else {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000392 if (Desc::kSolidWhite_ColorInput == fDesc.fColorInput) {
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000393 return GrGLSLOnesVecf(4);
senorblanco@chromium.orgb3a39b52012-01-05 18:28:56 +0000394 } else {
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000395 return GrGLSLZerosVecf(4);
senorblanco@chromium.orgb3a39b52012-01-05 18:28:56 +0000396 }
397 }
398}
399
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000400namespace {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000401// prints a shader using params similar to glShaderSource
402void print_shader(GrGLint stringCnt,
403 const GrGLchar** strings,
404 GrGLint* stringLengths) {
405 for (int i = 0; i < stringCnt; ++i) {
406 if (NULL == stringLengths || stringLengths[i] < 0) {
407 GrPrintf(strings[i]);
408 } else {
409 GrPrintf("%.*s", stringLengths[i], strings[i]);
410 }
411 }
412}
413
414// Compiles a GL shader, returns shader ID or 0 if failed params have same meaning as glShaderSource
415GrGLuint compile_shader(const GrGLContextInfo& gl,
416 GrGLenum type,
417 int stringCnt,
418 const char** strings,
419 int* stringLengths) {
420 SK_TRACE_EVENT1("GrGLProgram::CompileShader",
421 "stringCount", SkStringPrintf("%i", stringCnt).c_str());
422
423 GrGLuint shader;
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000424 GR_GL_CALL_RET(gl.interface(), shader, CreateShader(type));
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000425 if (0 == shader) {
426 return 0;
427 }
428
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000429 const GrGLInterface* gli = gl.interface();
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000430 GrGLint compiled = GR_GL_INIT_ZERO;
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000431 GR_GL_CALL(gli, ShaderSource(shader, stringCnt, strings, stringLengths));
432 GR_GL_CALL(gli, CompileShader(shader));
433 GR_GL_CALL(gli, GetShaderiv(shader, GR_GL_COMPILE_STATUS, &compiled));
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000434
435 if (!compiled) {
436 GrGLint infoLen = GR_GL_INIT_ZERO;
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000437 GR_GL_CALL(gli, GetShaderiv(shader, GR_GL_INFO_LOG_LENGTH, &infoLen));
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000438 SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
439 if (infoLen > 0) {
440 // retrieve length even though we don't need it to workaround bug in chrome cmd buffer
441 // param validation.
442 GrGLsizei length = GR_GL_INIT_ZERO;
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000443 GR_GL_CALL(gli, GetShaderInfoLog(shader, infoLen+1,
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000444 &length, (char*)log.get()));
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000445 print_shader(stringCnt, strings, stringLengths);
446 GrPrintf("\n%s", log.get());
447 }
448 GrAssert(!"Shader compilation failed!");
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000449 GR_GL_CALL(gli, DeleteShader(shader));
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000450 return 0;
451 }
452 return shader;
453}
454
455// helper version of above for when shader is already flattened into a single SkString
456GrGLuint compile_shader(const GrGLContextInfo& gl, GrGLenum type, const SkString& shader) {
457 const GrGLchar* str = shader.c_str();
458 int length = shader.size();
459 return compile_shader(gl, type, 1, &str, &length);
460}
461
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000462}
463
464// compiles all the shaders from builder and stores the shader IDs
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000465bool GrGLProgram::compileShaders(const GrGLShaderBuilder& builder) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000466
467 SkString shader;
468
469 builder.getShader(GrGLShaderBuilder::kVertex_ShaderType, &shader);
470#if PRINT_SHADERS
471 GrPrintf(shader.c_str());
472 GrPrintf("\n");
473#endif
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000474 if (!(fVShaderID = compile_shader(fContextInfo, GR_GL_VERTEX_SHADER, shader))) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000475 return false;
476 }
477
478 if (builder.fUsesGS) {
479 builder.getShader(GrGLShaderBuilder::kGeometry_ShaderType, &shader);
480#if PRINT_SHADERS
481 GrPrintf(shader.c_str());
482 GrPrintf("\n");
483#endif
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000484 if (!(fGShaderID = compile_shader(fContextInfo, GR_GL_GEOMETRY_SHADER, shader))) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000485 return false;
486 }
487 } else {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000488 fGShaderID = 0;
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000489 }
490
491 builder.getShader(GrGLShaderBuilder::kFragment_ShaderType, &shader);
492#if PRINT_SHADERS
493 GrPrintf(shader.c_str());
494 GrPrintf("\n");
495#endif
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000496 if (!(fFShaderID = compile_shader(fContextInfo, GR_GL_FRAGMENT_SHADER, shader))) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000497 return false;
498 }
499
500 return true;
501}
502
bsalomon@google.comf271cc72012-10-24 19:35:13 +0000503bool GrGLProgram::genProgram(const GrEffect** effects) {
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000504 GrAssert(0 == fProgramID);
505
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000506 GrGLShaderBuilder builder(fContextInfo, fUniformManager);
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000507 const uint32_t& layout = fDesc.fVertexLayout;
junov@google.comf93e7172011-03-31 21:26:24 +0000508
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000509#if GR_GL_EXPERIMENTAL_GS
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000510 builder.fUsesGS = fDesc.fExperimentalGS;
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000511#endif
512
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000513 SkXfermode::Coeff colorCoeff, uniformCoeff;
514 // The rest of transfer mode color filters have not been implemented
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000515 if (fDesc.fColorFilterXfermode < SkXfermode::kCoeffModesCnt) {
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000516 GR_DEBUGCODE(bool success =)
tomhudson@google.com0d831722011-06-02 15:37:14 +0000517 SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000518 (fDesc.fColorFilterXfermode),
tomhudson@google.com0d831722011-06-02 15:37:14 +0000519 &uniformCoeff, &colorCoeff);
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000520 GR_DEBUGASSERT(success);
521 } else {
522 colorCoeff = SkXfermode::kOne_Coeff;
523 uniformCoeff = SkXfermode::kZero_Coeff;
524 }
525
bsalomon@google.com67e78c92012-10-17 13:36:14 +0000526 // no need to do the color filter if coverage is 0. The output color is scaled by the coverage.
527 // All the dual source outputs are scaled by the coverage as well.
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000528 if (Desc::kTransBlack_ColorInput == fDesc.fCoverageInput) {
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000529 colorCoeff = SkXfermode::kZero_Coeff;
530 uniformCoeff = SkXfermode::kZero_Coeff;
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000531 }
532
bsalomon@google.com86c1f712011-10-12 14:54:26 +0000533 // If we know the final color is going to be all zeros then we can
bsalomon@google.com67e78c92012-10-17 13:36:14 +0000534 // simplify the color filter coefficients. needComputedColor will then
bsalomon@google.com86c1f712011-10-12 14:54:26 +0000535 // come out false below.
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000536 if (Desc::kTransBlack_ColorInput == fDesc.fColorInput) {
bsalomon@google.com86c1f712011-10-12 14:54:26 +0000537 colorCoeff = SkXfermode::kZero_Coeff;
538 if (SkXfermode::kDC_Coeff == uniformCoeff ||
539 SkXfermode::kDA_Coeff == uniformCoeff) {
540 uniformCoeff = SkXfermode::kZero_Coeff;
541 } else if (SkXfermode::kIDC_Coeff == uniformCoeff ||
542 SkXfermode::kIDA_Coeff == uniformCoeff) {
543 uniformCoeff = SkXfermode::kOne_Coeff;
544 }
545 }
546
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000547 bool needColorFilterUniform;
548 bool needComputedColor;
549 needBlendInputs(uniformCoeff, colorCoeff,
550 &needColorFilterUniform, &needComputedColor);
551
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000552 // the dual source output has no canonical var name, have to
553 // declare an output, which is incompatible with gl_FragColor/gl_FragData.
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000554 bool dualSourceOutputWritten = false;
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000555 builder.fHeader.append(GrGetGLSLVersionDecl(fContextInfo.binding(),
556 fContextInfo.glslGeneration()));
bsalomon@google.come55fd0f2012-02-10 15:56:06 +0000557
558 GrGLShaderVar colorOutput;
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000559 bool isColorDeclared = GrGLSLSetupFSColorOuput(fContextInfo.glslGeneration(),
bsalomon@google.come55fd0f2012-02-10 15:56:06 +0000560 declared_color_output_name(),
561 &colorOutput);
562 if (isColorDeclared) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000563 builder.fFSOutputs.push_back(colorOutput);
bsalomon@google.come55fd0f2012-02-10 15:56:06 +0000564 }
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000565
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000566 const char* viewMName;
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000567 fUniforms.fViewMatrixUni = builder.addUniform(GrGLShaderBuilder::kVertex_ShaderType,
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000568 kMat33f_GrSLType, "ViewM", &viewMName);
bsalomon@google.com341767c2012-05-11 20:47:39 +0000569
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000570 builder.fVSAttrs.push_back().set(kVec2f_GrSLType,
571 GrGLShaderVar::kAttribute_TypeModifier,
572 POS_ATTR_NAME);
junov@google.comf93e7172011-03-31 21:26:24 +0000573
bsalomon@google.comd7bafb72012-10-22 14:30:50 +0000574 builder.fVSCode.appendf("\tvec3 pos3 = %s * vec3("POS_ATTR_NAME", 1);\n"
575 "\tgl_Position = vec4(pos3.xy, 0, pos3.z);\n",
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000576 viewMName);
bsalomon@google.com4be283f2011-04-19 21:15:09 +0000577
bsalomon@google.com91961302011-05-09 18:39:58 +0000578 // incoming color to current stage being processed.
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000579 SkString inColor;
bsalomon@google.com4be283f2011-04-19 21:15:09 +0000580
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000581 if (needComputedColor) {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000582 this->genInputColor(&builder, &inColor);
junov@google.comf93e7172011-03-31 21:26:24 +0000583 }
584
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000585 // we output point size in the GS if present
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000586 if (fDesc.fEmitsPointSize && !builder.fUsesGS){
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000587 builder.fVSCode.append("\tgl_PointSize = 1.0;\n");
junov@google.comf93e7172011-03-31 21:26:24 +0000588 }
bsalomon@google.com4be283f2011-04-19 21:15:09 +0000589
junov@google.comf93e7172011-03-31 21:26:24 +0000590 // add texture coordinates that are used to the list of vertex attr decls
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000591 SkString texCoordAttrs[GrDrawState::kMaxTexCoords];
tomhudson@google.com93813632011-10-27 20:21:16 +0000592 for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
bsalomon@google.com6aef1fb2011-05-05 12:33:22 +0000593 if (GrDrawTarget::VertexUsesTexCoordIdx(t, layout)) {
junov@google.comf93e7172011-03-31 21:26:24 +0000594 tex_attr_name(t, texCoordAttrs + t);
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000595 builder.fVSAttrs.push_back().set(kVec2f_GrSLType,
tomhudson@google.com086e5352011-12-08 14:44:10 +0000596 GrGLShaderVar::kAttribute_TypeModifier,
597 texCoordAttrs[t].c_str());
junov@google.comf93e7172011-03-31 21:26:24 +0000598 }
599 }
600
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000601 ///////////////////////////////////////////////////////////////////////////
602 // compute the final color
Scroggo97c88c22011-05-11 14:05:25 +0000603
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000604 // if we have color stages string them together, feeding the output color
605 // of each to the next and generating code for each stage.
606 if (needComputedColor) {
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000607 SkString outColor;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000608 for (int s = 0; s < fDesc.fFirstCoverageStage; ++s) {
609 if (fDesc.fStages[s].isEnabled()) {
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000610 // create var to hold stage result
611 outColor = "color";
612 outColor.appendS32(s);
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000613 builder.fFSCode.appendf("\tvec4 %s;\n", outColor.c_str());
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000614
615 const char* inCoords;
616 // figure out what our input coords are
tomhudson@google.comb213ed82012-06-25 15:22:12 +0000617 int tcIdx = GrDrawTarget::VertexTexCoordsForStage(s, layout);
618 if (tcIdx < 0) {
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000619 inCoords = POS_ATTR_NAME;
Scroggo97c88c22011-05-11 14:05:25 +0000620 } else {
tomhudson@google.comb213ed82012-06-25 15:22:12 +0000621 // must have input tex coordinates if stage is enabled.
Scroggo97c88c22011-05-11 14:05:25 +0000622 GrAssert(texCoordAttrs[tcIdx].size());
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000623 inCoords = texCoordAttrs[tcIdx].c_str();
junov@google.comf93e7172011-03-31 21:26:24 +0000624 }
625
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000626 builder.setCurrentStage(s);
bsalomon@google.comf271cc72012-10-24 19:35:13 +0000627 fProgramStage[s] = GenStageCode(effects[s],
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000628 fDesc.fStages[s],
629 &fUniforms.fStages[s],
630 inColor.size() ? inColor.c_str() : NULL,
631 outColor.c_str(),
632 inCoords,
633 &builder);
634 builder.setNonStage();
junov@google.comf93e7172011-03-31 21:26:24 +0000635 inColor = outColor;
junov@google.comf93e7172011-03-31 21:26:24 +0000636 }
637 }
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000638 }
Scroggo97c88c22011-05-11 14:05:25 +0000639
bsalomon@google.com86c1f712011-10-12 14:54:26 +0000640 // if have all ones or zeros for the "dst" input to the color filter then we
641 // may be able to make additional optimizations.
642 if (needColorFilterUniform && needComputedColor && !inColor.size()) {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000643 GrAssert(Desc::kSolidWhite_ColorInput == fDesc.fColorInput);
bsalomon@google.com86c1f712011-10-12 14:54:26 +0000644 bool uniformCoeffIsZero = SkXfermode::kIDC_Coeff == uniformCoeff ||
645 SkXfermode::kIDA_Coeff == uniformCoeff;
646 if (uniformCoeffIsZero) {
647 uniformCoeff = SkXfermode::kZero_Coeff;
648 bool bogus;
649 needBlendInputs(SkXfermode::kZero_Coeff, colorCoeff,
650 &needColorFilterUniform, &bogus);
651 }
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000652 }
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000653 const char* colorFilterColorUniName = NULL;
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000654 if (needColorFilterUniform) {
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000655 fUniforms.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000656 kVec4f_GrSLType, "FilterColor",
657 &colorFilterColorUniName);
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000658 }
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000659 bool wroteFragColorZero = false;
tomhudson@google.com0d831722011-06-02 15:37:14 +0000660 if (SkXfermode::kZero_Coeff == uniformCoeff &&
bsalomon@google.com67e78c92012-10-17 13:36:14 +0000661 SkXfermode::kZero_Coeff == colorCoeff) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000662 builder.fFSCode.appendf("\t%s = %s;\n",
663 colorOutput.getName().c_str(),
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000664 GrGLSLZerosVecf(4));
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000665 wroteFragColorZero = true;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000666 } else if (SkXfermode::kDst_Mode != fDesc.fColorFilterXfermode) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000667 builder.fFSCode.append("\tvec4 filteredColor;\n");
senorblanco@chromium.orgb3a39b52012-01-05 18:28:56 +0000668 const char* color = adjustInColor(inColor);
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000669 addColorFilter(&builder.fFSCode, "filteredColor", uniformCoeff,
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000670 colorCoeff, colorFilterColorUniName, color);
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000671 inColor = "filteredColor";
672 }
673
674 ///////////////////////////////////////////////////////////////////////////
675 // compute the partial coverage (coverage stages and edge aa)
676
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000677 SkString inCoverage;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000678 bool coverageIsZero = Desc::kTransBlack_ColorInput == fDesc.fCoverageInput;
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000679 // we don't need to compute coverage at all if we know the final shader
680 // output will be zero and we don't have a dual src blend output.
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000681 if (!wroteFragColorZero || Desc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
bsalomon@google.com66105672011-09-15 15:12:00 +0000682
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000683 if (!coverageIsZero) {
bsalomon@google.comd4726202012-08-03 14:34:46 +0000684 bool inCoverageIsScalar = this->genEdgeCoverage(&inCoverage, &builder);
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000685
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000686 switch (fDesc.fCoverageInput) {
687 case Desc::kSolidWhite_ColorInput:
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000688 // empty string implies solid white
689 break;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000690 case Desc::kAttribute_ColorInput:
691 gen_attribute_coverage(&builder, &inCoverage);
bsalomon@google.comd4726202012-08-03 14:34:46 +0000692 inCoverageIsScalar = false;
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000693 break;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000694 case Desc::kUniform_ColorInput:
695 this->genUniformCoverage(&builder, &inCoverage);
bsalomon@google.comd4726202012-08-03 14:34:46 +0000696 inCoverageIsScalar = false;
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000697 break;
698 default:
699 GrCrash("Unexpected input coverage.");
700 }
bsalomon@google.coma3108262011-10-10 14:08:47 +0000701
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000702 SkString outCoverage;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000703 const int& startStage = fDesc.fFirstCoverageStage;
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000704 for (int s = startStage; s < GrDrawState::kNumStages; ++s) {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000705 if (fDesc.fStages[s].isEnabled()) {
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000706 // create var to hold stage output
707 outCoverage = "coverage";
708 outCoverage.appendS32(s);
bsalomon@google.comd4726202012-08-03 14:34:46 +0000709 builder.fFSCode.appendf("\tvec4 %s;\n", outCoverage.c_str());
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000710
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000711 const char* inCoords;
712 // figure out what our input coords are
tomhudson@google.comb213ed82012-06-25 15:22:12 +0000713 int tcIdx =
714 GrDrawTarget::VertexTexCoordsForStage(s, layout);
715 if (tcIdx < 0) {
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000716 inCoords = POS_ATTR_NAME;
717 } else {
tomhudson@google.comb213ed82012-06-25 15:22:12 +0000718 // must have input tex coordinates if stage is
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000719 // enabled.
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000720 GrAssert(texCoordAttrs[tcIdx].size());
721 inCoords = texCoordAttrs[tcIdx].c_str();
722 }
723
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000724 // stages don't know how to deal with a scalar input. (Maybe they should. We
bsalomon@google.comd4726202012-08-03 14:34:46 +0000725 // could pass a GrGLShaderVar)
726 if (inCoverageIsScalar) {
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000727 builder.fFSCode.appendf("\tvec4 %s4 = vec4(%s);\n",
bsalomon@google.comd4726202012-08-03 14:34:46 +0000728 inCoverage.c_str(), inCoverage.c_str());
729 inCoverage.append("4");
730 }
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000731 builder.setCurrentStage(s);
bsalomon@google.comf271cc72012-10-24 19:35:13 +0000732 fProgramStage[s] = GenStageCode(effects[s],
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000733 fDesc.fStages[s],
734 &fUniforms.fStages[s],
735 inCoverage.size() ? inCoverage.c_str() : NULL,
736 outCoverage.c_str(),
737 inCoords,
738 &builder);
739 builder.setNonStage();
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000740 inCoverage = outCoverage;
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000741 }
senorblanco@chromium.org92e0f222011-05-12 15:49:15 +0000742 }
743 }
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000744
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000745 if (Desc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000746 builder.fFSOutputs.push_back().set(kVec4f_GrSLType,
747 GrGLShaderVar::kOut_TypeModifier,
748 dual_source_output_name());
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000749 bool outputIsZero = coverageIsZero;
bsalomon@google.comf0a104e2012-07-10 17:51:07 +0000750 SkString coeff;
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000751 if (!outputIsZero &&
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000752 Desc::kCoverage_DualSrcOutput != fDesc.fDualSrcOutput && !wroteFragColorZero) {
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000753 if (!inColor.size()) {
754 outputIsZero = true;
755 } else {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000756 if (Desc::kCoverageISA_DualSrcOutput == fDesc.fDualSrcOutput) {
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000757 coeff.printf("(1 - %s.a)", inColor.c_str());
758 } else {
759 coeff.printf("(vec4(1,1,1,1) - %s)", inColor.c_str());
760 }
761 }
762 }
763 if (outputIsZero) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000764 builder.fFSCode.appendf("\t%s = %s;\n",
765 dual_source_output_name(),
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000766 GrGLSLZerosVecf(4));
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000767 } else {
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000768 builder.fFSCode.appendf("\t%s =", dual_source_output_name());
769 GrGLSLModulate4f(&builder.fFSCode, coeff.c_str(), inCoverage.c_str());
770 builder.fFSCode.append(";\n");
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000771 }
772 dualSourceOutputWritten = true;
773 }
junov@google.comf93e7172011-03-31 21:26:24 +0000774 }
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000775
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000776 ///////////////////////////////////////////////////////////////////////////
777 // combine color and coverage as frag color
778
779 if (!wroteFragColorZero) {
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000780 if (coverageIsZero) {
bsalomon@google.comad5e9372012-07-11 18:11:27 +0000781 builder.fFSCode.appendf("\t%s = %s;\n",
782 colorOutput.getName().c_str(),
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000783 GrGLSLZerosVecf(4));
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000784 } else {
bsalomon@google.com4af0af62012-08-29 12:59:57 +0000785 builder.fFSCode.appendf("\t%s = ", colorOutput.getName().c_str());
786 GrGLSLModulate4f(&builder.fFSCode, inColor.c_str(), inCoverage.c_str());
787 builder.fFSCode.append(";\n");
bsalomon@google.com2401ae82012-01-17 21:03:05 +0000788 }
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000789 }
790
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000791 ///////////////////////////////////////////////////////////////////////////
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000792 // insert GS
793#if GR_DEBUG
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000794 this->genGeometryShader(&builder);
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000795#endif
796
797 ///////////////////////////////////////////////////////////////////////////
bsalomon@google.comf2d91552011-05-16 20:56:06 +0000798 // compile and setup attribs and unis
799
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000800 if (!this->compileShaders(builder)) {
bsalomon@google.com91961302011-05-09 18:39:58 +0000801 return false;
802 }
803
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000804 if (!this->bindOutputsAttribsAndLinkProgram(texCoordAttrs,
bsalomon@google.com4fa66942011-09-20 19:06:12 +0000805 isColorDeclared,
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000806 dualSourceOutputWritten)) {
bsalomon@google.com91961302011-05-09 18:39:58 +0000807 return false;
808 }
809
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000810 builder.finished(fProgramID);
811 this->initSamplerUniforms();
bsalomon@google.com706f6682012-10-23 14:53:55 +0000812 fUniforms.fRTHeight = builder.getRTHeightUniform();
bsalomon@google.com91961302011-05-09 18:39:58 +0000813
814 return true;
815}
816
bsalomon@google.comecb60aa2012-07-18 13:20:29 +0000817bool GrGLProgram::bindOutputsAttribsAndLinkProgram(SkString texCoordAttrNames[],
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000818 bool bindColorOut,
819 bool bindDualSrcOut) {
820 GL_CALL_RET(fProgramID, CreateProgram());
821 if (!fProgramID) {
bsalomon@google.com91961302011-05-09 18:39:58 +0000822 return false;
823 }
bsalomon@google.com91961302011-05-09 18:39:58 +0000824
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000825 GL_CALL(AttachShader(fProgramID, fVShaderID));
826 if (fGShaderID) {
827 GL_CALL(AttachShader(fProgramID, fGShaderID));
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000828 }
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000829 GL_CALL(AttachShader(fProgramID, fFShaderID));
bsalomon@google.com91961302011-05-09 18:39:58 +0000830
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000831 if (bindColorOut) {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000832 GL_CALL(BindFragDataLocation(fProgramID, 0, declared_color_output_name()));
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000833 }
834 if (bindDualSrcOut) {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000835 GL_CALL(BindFragDataLocationIndexed(fProgramID, 0, 1, dual_source_output_name()));
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000836 }
837
bsalomon@google.com91961302011-05-09 18:39:58 +0000838 // Bind the attrib locations to same values for all shaders
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000839 GL_CALL(BindAttribLocation(fProgramID, PositionAttributeIdx(), POS_ATTR_NAME));
tomhudson@google.com93813632011-10-27 20:21:16 +0000840 for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
bsalomon@google.com91961302011-05-09 18:39:58 +0000841 if (texCoordAttrNames[t].size()) {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000842 GL_CALL(BindAttribLocation(fProgramID,
bsalomon@google.com96399942012-02-13 14:39:16 +0000843 TexCoordAttributeIdx(t),
844 texCoordAttrNames[t].c_str()));
bsalomon@google.com91961302011-05-09 18:39:58 +0000845 }
846 }
847
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000848 GL_CALL(BindAttribLocation(fProgramID, ColorAttributeIdx(), COL_ATTR_NAME));
849 GL_CALL(BindAttribLocation(fProgramID, CoverageAttributeIdx(), COV_ATTR_NAME));
850 GL_CALL(BindAttribLocation(fProgramID, EdgeAttributeIdx(), EDGE_ATTR_NAME));
bsalomon@google.com91961302011-05-09 18:39:58 +0000851
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000852 GL_CALL(LinkProgram(fProgramID));
bsalomon@google.com91961302011-05-09 18:39:58 +0000853
854 GrGLint linked = GR_GL_INIT_ZERO;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000855 GL_CALL(GetProgramiv(fProgramID, GR_GL_LINK_STATUS, &linked));
bsalomon@google.com91961302011-05-09 18:39:58 +0000856 if (!linked) {
857 GrGLint infoLen = GR_GL_INIT_ZERO;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000858 GL_CALL(GetProgramiv(fProgramID, GR_GL_INFO_LOG_LENGTH, &infoLen));
bsalomon@google.com3582bf92011-06-30 21:32:31 +0000859 SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
bsalomon@google.com91961302011-05-09 18:39:58 +0000860 if (infoLen > 0) {
bsalomon@google.com79afcaa2011-09-14 14:29:18 +0000861 // retrieve length even though we don't need it to workaround
862 // bug in chrome cmd buffer param validation.
863 GrGLsizei length = GR_GL_INIT_ZERO;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000864 GL_CALL(GetProgramInfoLog(fProgramID,
bsalomon@google.com96399942012-02-13 14:39:16 +0000865 infoLen+1,
866 &length,
867 (char*)log.get()));
bsalomon@google.com91961302011-05-09 18:39:58 +0000868 GrPrintf((char*)log.get());
869 }
870 GrAssert(!"Error linking program");
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000871 GL_CALL(DeleteProgram(fProgramID));
872 fProgramID = 0;
bsalomon@google.com91961302011-05-09 18:39:58 +0000873 return false;
874 }
875 return true;
876}
877
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000878void GrGLProgram::initSamplerUniforms() {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000879 GL_CALL(UseProgram(fProgramID));
tomhudson@google.com93813632011-10-27 20:21:16 +0000880 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
bsalomon@google.com0982d352012-07-31 15:33:25 +0000881 int count = fUniforms.fStages[s].fSamplerUniforms.count();
882 // FIXME: We're still always reserving one texture per stage. After GrTextureParams are
bsalomon@google.comf271cc72012-10-24 19:35:13 +0000883 // expressed by the effect rather than the GrSamplerState we can move texture binding
bsalomon@google.com0982d352012-07-31 15:33:25 +0000884 // into GrGLProgram and it should be easier to fix this.
885 GrAssert(count <= 1);
886 for (int t = 0; t < count; ++t) {
887 UniformHandle uh = fUniforms.fStages[s].fSamplerUniforms[t];
888 if (GrGLUniformManager::kInvalidUniformHandle != uh) {
889 fUniformManager.setSampler(uh, s);
890 }
bsalomon@google.com91961302011-05-09 18:39:58 +0000891 }
bsalomon@google.com91961302011-05-09 18:39:58 +0000892 }
bsalomon@google.com91961302011-05-09 18:39:58 +0000893}
894
bsalomon@google.comeb715c82012-07-11 15:03:31 +0000895///////////////////////////////////////////////////////////////////////////////
junov@google.comf93e7172011-03-31 21:26:24 +0000896// Stage code generation
junov@google.comf93e7172011-03-31 21:26:24 +0000897
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000898// TODO: Move this function to GrGLShaderBuilder
bsalomon@google.comd698f772012-10-25 13:22:00 +0000899GrGLEffect* GrGLProgram::GenStageCode(const GrEffect* effect,
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000900 const StageDesc& desc,
901 StageUniforms* uniforms,
902 const char* fsInColor, // NULL means no incoming color
903 const char* fsOutColor,
904 const char* vsInCoord,
905 GrGLShaderBuilder* builder) {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000906
bsalomon@google.comd698f772012-10-25 13:22:00 +0000907 GrGLEffect* glStage = effect->getFactory().createGLInstance(*effect);
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000908
tomhudson@google.com23cb2292012-05-30 18:26:03 +0000909 /// Vertex Shader Stuff
910
bsalomon@google.comeb715c82012-07-11 15:03:31 +0000911 // decide whether we need a matrix to transform texture coords and whether the varying needs a
912 // perspective coord.
bsalomon@google.com4fa66942011-09-20 19:06:12 +0000913 const char* matName = NULL;
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000914 GrSLType texCoordVaryingType;
bsalomon@google.com22c5dea2011-07-07 14:38:03 +0000915 if (desc.fOptFlags & StageDesc::kIdentityMatrix_OptFlagBit) {
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000916 texCoordVaryingType = kVec2f_GrSLType;
junov@google.comf93e7172011-03-31 21:26:24 +0000917 } else {
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000918 uniforms->fTextureMatrixUni = builder->addUniform(GrGLShaderBuilder::kVertex_ShaderType,
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000919 kMat33f_GrSLType, "TexM", &matName);
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000920 builder->getUniformVariable(uniforms->fTextureMatrixUni);
bsalomon@google.com4fa66942011-09-20 19:06:12 +0000921
bsalomon@google.com22c5dea2011-07-07 14:38:03 +0000922 if (desc.fOptFlags & StageDesc::kNoPerspective_OptFlagBit) {
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000923 texCoordVaryingType = kVec2f_GrSLType;
junov@google.comf93e7172011-03-31 21:26:24 +0000924 } else {
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000925 texCoordVaryingType = kVec3f_GrSLType;
junov@google.comf93e7172011-03-31 21:26:24 +0000926 }
927 }
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000928 const char *varyingVSName, *varyingFSName;
929 builder->addVarying(texCoordVaryingType,
930 "Stage",
931 &varyingVSName,
932 &varyingFSName);
933 builder->setupTextureAccess(varyingFSName, texCoordVaryingType);
junov@google.comf93e7172011-03-31 21:26:24 +0000934
bsalomon@google.com021fc732012-10-25 12:47:42 +0000935 int numTextures = effect->numTextures();
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000936 SkSTArray<8, GrGLShaderBuilder::TextureSampler> textureSamplers;
bsalomon@google.com2d8edaf2012-09-07 14:47:31 +0000937
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000938 textureSamplers.push_back_n(numTextures);
bsalomon@google.com2d8edaf2012-09-07 14:47:31 +0000939
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000940 for (int i = 0; i < numTextures; ++i) {
bsalomon@google.com021fc732012-10-25 12:47:42 +0000941 textureSamplers[i].init(builder, &effect->textureAccess(i));
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000942 uniforms->fSamplerUniforms.push_back(textureSamplers[i].fSamplerUniform);
943 }
junov@google.comf93e7172011-03-31 21:26:24 +0000944
bsalomon@google.com4fa66942011-09-20 19:06:12 +0000945 if (!matName) {
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000946 GrAssert(kVec2f_GrSLType == texCoordVaryingType);
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000947 builder->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord);
junov@google.comf93e7172011-03-31 21:26:24 +0000948 } else {
bsalomon@google.com91961302011-05-09 18:39:58 +0000949 // varying = texMatrix * texCoord
bsalomon@google.com777c3aa2012-07-25 20:58:20 +0000950 builder->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n",
bsalomon@google.comedfe1aa2011-09-29 14:40:26 +0000951 varyingVSName, matName, vsInCoord,
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000952 vector_all_coords(GrSLTypeToVecLength(texCoordVaryingType)));
junov@google.comf93e7172011-03-31 21:26:24 +0000953 }
954
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000955 // Enclose custom code in a block to avoid namespace conflicts
bsalomon@google.com374e7592012-10-23 17:30:45 +0000956 builder->fVSCode.appendf("\t{ // %s\n", glStage->name());
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000957 builder->fFSCode.appendf("\t{ // %s \n", glStage->name());
bsalomon@google.com96182212012-10-24 17:34:46 +0000958 glStage->emitCode(builder,
bsalomon@google.com021fc732012-10-25 12:47:42 +0000959 *effect,
bsalomon@google.com96182212012-10-24 17:34:46 +0000960 desc.fCustomStageKey,
961 varyingVSName,
962 fsOutColor,
963 fsInColor,
964 textureSamplers);
bsalomon@google.com374e7592012-10-23 17:30:45 +0000965 builder->fVSCode.appendf("\t}\n");
bsalomon@google.com34bcb9f2012-08-28 18:20:18 +0000966 builder->fFSCode.appendf("\t}\n");
bsalomon@google.comf06df1b2012-09-06 20:22:31 +0000967
968 return glStage;
junov@google.comf93e7172011-03-31 21:26:24 +0000969}
bsalomon@google.com4285acc2012-10-22 14:11:24 +0000970
bsalomon@google.com706f6682012-10-23 14:53:55 +0000971void GrGLProgram::setData(const GrDrawState& drawState) {
972 int rtHeight = drawState.getRenderTarget()->height();
973 if (GrGLUniformManager::kInvalidUniformHandle != fUniforms.fRTHeight && fRTHeight != rtHeight) {
974 fUniformManager.set1f(fUniforms.fRTHeight, GrIntToScalar(rtHeight));
975 fRTHeight = rtHeight;
976 }
bsalomon@google.com4285acc2012-10-22 14:11:24 +0000977 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
978 if (NULL != fProgramStage[s]) {
979 const GrSamplerState& sampler = drawState.getSampler(s);
bsalomon@google.com6f261be2012-10-24 19:07:10 +0000980 GrAssert(NULL != sampler.getEffect());
981 fProgramStage[s]->setData(fUniformManager, *sampler.getEffect());
bsalomon@google.com4285acc2012-10-22 14:11:24 +0000982 }
983 }
984}