Add experimental geometry shader code to gpu backend
Review URL: http://codereview.appspot.com/5129047/
git-svn-id: http://skia.googlecode.com/svn/trunk@2365 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gpu/src/GrGLProgram.cpp b/gpu/src/GrGLProgram.cpp
index 015be61..cbe2f42 100644
--- a/gpu/src/GrGLProgram.cpp
+++ b/gpu/src/GrGLProgram.cpp
@@ -47,18 +47,29 @@
ShaderCodeSegments()
: fVSUnis(gVarsPerBlock)
, fVSAttrs(gVarsPerBlock)
- , fVaryings(gVarsPerBlock)
+ , fVSOutputs(gVarsPerBlock)
+ , fGSInputs(gVarsPerBlock)
+ , fGSOutputs(gVarsPerBlock)
+ , fFSInputs(gVarsPerBlock)
, fFSUnis(gVarsPerBlock)
- , fFSOutputs(gMaxFSOutputs) {}
+ , fFSOutputs(gMaxFSOutputs)
+ , fUsesGS(false) {}
GrStringBuilder fHeader; // VS+FS, GLSL version, etc
VarArray fVSUnis;
VarArray fVSAttrs;
- VarArray fVaryings;
+ VarArray fVSOutputs;
+ VarArray fGSInputs;
+ VarArray fGSOutputs;
+ VarArray fFSInputs;
+ GrStringBuilder fGSHeader; // layout qualifiers specific to GS
VarArray fFSUnis;
VarArray fFSOutputs;
GrStringBuilder fFSFunctions;
GrStringBuilder fVSCode;
+ GrStringBuilder fGSCode;
GrStringBuilder fFSCode;
+
+ bool fUsesGS;
};
@@ -148,21 +159,11 @@
s->appendS32(stage);
}
-inline void stage_varying_name(int stage, GrStringBuilder* s) {
- *s = "vStage";
- s->appendS32(stage);
-}
-
inline void radial2_param_name(int stage, GrStringBuilder* s) {
*s = "uRadial2Params";
s->appendS32(stage);
}
-inline void radial2_varying_name(int stage, GrStringBuilder* s) {
- *s = "vB";
- s->appendS32(stage);
-}
-
inline void convolve_param_names(int stage, GrStringBuilder* k, GrStringBuilder* i) {
*k = "uKernel";
k->appendS32(stage);
@@ -372,12 +373,65 @@
case GrGLProgram::k130_GLSLVersion:
GrAssert(!gl->supportsES());
return "#version 130\n";
+ case GrGLProgram::k150_GLSLVersion:
+ GrAssert(!gl->supportsES());
+ return "#version 150\n";
default:
GrCrash("Unknown GL version.");
return ""; // suppress warning
}
}
+// Adds a var that is computed in the VS and read in FS.
+// If there is a GS it will just pass it through.
+void append_varying(GrGLShaderVar::Type type,
+ const char* name,
+ ShaderCodeSegments* segments,
+ const char** vsOutName = NULL,
+ const char** fsInName = NULL) {
+ segments->fVSOutputs.push_back();
+ segments->fVSOutputs.back().setType(type);
+ segments->fVSOutputs.back().accessName()->printf("v%s", name);
+ if (vsOutName) {
+ *vsOutName = segments->fVSOutputs.back().getName().c_str();
+ }
+ // input to FS comes either from VS or GS
+ const GrStringBuilder* fsName;
+ if (segments->fUsesGS) {
+ // if we have a GS take each varying in as an array
+ // and output as non-array.
+ segments->fGSInputs.push_back();
+ segments->fGSInputs.back().setType(type);
+ segments->fGSInputs.back().setUnsizedArray();
+ *segments->fGSInputs.back().accessName() =
+ segments->fVSOutputs.back().getName();
+ segments->fGSOutputs.push_back();
+ segments->fGSOutputs.back().setType(type);
+ segments->fGSOutputs.back().accessName()->printf("g%s", name);
+ fsName = segments->fGSOutputs.back().accessName();
+ } else {
+ fsName = segments->fVSOutputs.back().accessName();
+ }
+ segments->fFSInputs.push_back();
+ segments->fFSInputs.back().setType(type);
+ segments->fFSInputs.back().setName(*fsName);
+ if (fsInName) {
+ *fsInName = fsName->c_str();
+ }
+}
+
+// version of above that adds a stage number to the
+// the var name (for uniqueness)
+void append_varying(GrGLShaderVar::Type type,
+ const char* name,
+ int stageNum,
+ ShaderCodeSegments* segments,
+ const char** vsOutName = NULL,
+ const char** fsInName = NULL) {
+ GrStringBuilder nameWithStage(name);
+ nameWithStage.appendS32(stageNum);
+ append_varying(type, nameWithStage.c_str(), segments, vsOutName, fsInName);
+}
}
void GrGLProgram::genEdgeCoverage(const GrGLInterface* gl,
@@ -435,20 +489,21 @@
}
*coverageVar = "edgeAlpha";
} else if (layout & GrDrawTarget::kEdge_VertexLayoutBit) {
- segments->fVaryings.push_back().set(GrGLShaderVar::kVec4f_Type, "vEdge");
+ const char *vsName, *fsName;
+ append_varying(GrGLShaderVar::kVec4f_Type, "Edge", segments, &vsName, &fsName);
segments->fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type, EDGE_ATTR_NAME);
- segments->fVSCode.append("\tvEdge = " EDGE_ATTR_NAME ";\n");
+ segments->fVSCode.appendf("\t%s = " EDGE_ATTR_NAME ";\n", vsName);
if (GrDrawTarget::kHairLine_EdgeType == fProgramDesc.fVertexEdgeType) {
- segments->fFSCode.append("\tfloat edgeAlpha = abs(dot(vec3(gl_FragCoord.xy,1), vEdge.xyz));\n");
+ segments->fFSCode.appendf("\tfloat edgeAlpha = abs(dot(vec3(gl_FragCoord.xy,1), %s.xyz));\n", fsName);
} else {
GrAssert(GrDrawTarget::kHairQuad_EdgeType == fProgramDesc.fVertexEdgeType);
// for now we know we're not in perspective, so we could compute this
// per-quadratic rather than per pixel
- segments->fFSCode.append("\tvec2 duvdx = dFdx(vEdge.xy);\n");
- segments->fFSCode.append("\tvec2 duvdy = dFdy(vEdge.xy);\n");
- segments->fFSCode.append("\tfloat dfdx = 2.0*vEdge.x*duvdx.x - duvdx.y;\n");
- segments->fFSCode.append("\tfloat dfdy = 2.0*vEdge.x*duvdy.x - duvdy.y;\n");
- segments->fFSCode.append("\tfloat edgeAlpha = (vEdge.x*vEdge.x - vEdge.y);\n");
+ segments->fFSCode.appendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
+ segments->fFSCode.appendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
+ segments->fFSCode.appendf("\tfloat dfdx = 2.0*%s.x*duvdx.x - duvdx.y;\n", fsName);
+ segments->fFSCode.appendf("\tfloat dfdy = 2.0*%s.x*duvdy.x - duvdy.y;\n", fsName);
+ segments->fFSCode.appendf("\tfloat edgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
segments->fFSCode.append("\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / (dfdx*dfdx + dfdy*dfdy));\n");
if (gl->supportsES()) {
segments->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
@@ -472,7 +527,8 @@
*name = "gl_FragColor";
return false;
break;
- case GrGLProgram::k130_GLSLVersion:
+ case GrGLProgram::k130_GLSLVersion: // fallthru
+ case GrGLProgram::k150_GLSLVersion:
*name = declared_color_output_name();
fsOutputs->push_back().set(GrGLShaderVar::kVec4f_Type,
declared_color_output_name());
@@ -486,6 +542,35 @@
}
+void GrGLProgram::genGeometryShader(const GrGLInterface* gl,
+ GLSLVersion glslVersion,
+ ShaderCodeSegments* segments) const {
+#if GR_GL_EXPERIMENTAL_GS
+ if (fProgramDesc.fExperimentalGS) {
+ GrAssert(glslVersion >= k150_GLSLVersion);
+ segments->fGSHeader.append("layout(triangles) in;\n"
+ "layout(triangle_strip, max_vertices = 6) out;\n");
+ segments->fGSCode.append("void main() {\n"
+ "\tfor (int i = 0; i < 3; ++i) {\n"
+ "\t\tgl_Position = gl_in[i].gl_Position;\n");
+ if (this->fProgramDesc.fEmitsPointSize) {
+ segments->fGSCode.append("\t\tgl_PointSize = 1.0;\n");
+ }
+ GrAssert(segments->fGSInputs.count() == segments->fGSOutputs.count());
+ int count = segments->fGSInputs.count();
+ for (int i = 0; i < count; ++i) {
+ segments->fGSCode.appendf("\t\t%s = %s[i];\n",
+ segments->fGSOutputs[i].getName().c_str(),
+ segments->fGSInputs[i].getName().c_str());
+ }
+ segments->fGSCode.append("\t\tEmitVertex();\n"
+ "\t}\n"
+ "\tEndPrimitive();\n"
+ "}\n");
+ }
+#endif
+}
+
bool GrGLProgram::genProgram(const GrGLInterface* gl,
GLSLVersion glslVersion,
GrGLProgram::CachedData* programData) const {
@@ -495,6 +580,10 @@
programData->fUniLocations.reset();
+#if GR_GL_EXPERIMENTAL_GS
+ segments.fUsesGS = fProgramDesc.fExperimentalGS;
+#endif
+
SkXfermode::Coeff colorCoeff, uniformCoeff;
// The rest of transfer mode color filters have not been implemented
if (fProgramDesc.fColorFilterXfermode < SkXfermode::kCoeffModesCnt) {
@@ -541,14 +630,14 @@
if (needComputedColor) {
switch (fProgramDesc.fColorType) {
- case ProgramDesc::kAttribute_ColorType:
+ case ProgramDesc::kAttribute_ColorType: {
segments.fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type,
COL_ATTR_NAME);
- segments.fVaryings.push_back().set(GrGLShaderVar::kVec4f_Type,
- "vColor");
- segments.fVSCode.append("\tvColor = " COL_ATTR_NAME ";\n");
- inColor = "vColor";
- break;
+ const char *vsName, *fsName;
+ append_varying(GrGLShaderVar::kVec4f_Type, "Color", &segments, &vsName, &fsName);
+ segments.fVSCode.appendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
+ inColor = fsName;
+ } break;
case ProgramDesc::kUniform_ColorType:
segments.fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
COL_UNI_NAME);
@@ -561,7 +650,8 @@
}
}
- if (fProgramDesc.fEmitsPointSize){
+ // we output point size in the GS if present
+ if (fProgramDesc.fEmitsPointSize && !segments.fUsesGS){
segments.fVSCode.append("\tgl_PointSize = 1.0;\n");
}
@@ -738,9 +828,15 @@
segments.fFSCode.append("}\n");
///////////////////////////////////////////////////////////////////////////
+ // insert GS
+#if GR_DEBUG
+ this->genGeometryShader(gl, glslVersion, &segments);
+#endif
+
+ ///////////////////////////////////////////////////////////////////////////
// compile and setup attribs and unis
- if (!CompileFSAndVS(gl, glslVersion, segments, programData)) {
+ if (!CompileShaders(gl, glslVersion, segments, programData)) {
return false;
}
@@ -758,22 +854,22 @@
namespace {
-void expand_decls(const VarArray& unis,
- const GrGLInterface* gl,
- const char* prefix,
- GrStringBuilder* string) {
- const int count = unis.count();
+inline void expand_decls(const VarArray& vars,
+ const GrGLInterface* gl,
+ const char* prefix,
+ GrStringBuilder* string) {
+ const int count = vars.count();
for (int i = 0; i < count; ++i) {
string->append(prefix);
string->append(" ");
- unis[i].appendDecl(gl, string);
+ vars[i].appendDecl(gl, string);
string->append(";\n");
}
}
-void print_shader(int stringCnt,
- const char** strings,
- int* stringLengths) {
+inline void print_shader(int stringCnt,
+ const char** strings,
+ int* stringLengths) {
for (int i = 0; i < stringCnt; ++i) {
if (NULL == stringLengths || stringLengths[i] < 0) {
GrPrintf(strings[i]);
@@ -782,126 +878,124 @@
}
}
}
+
+typedef SkTArray<const char*, true> StrArray;
+#define PREALLOC_STR_ARRAY(N) SkSTArray<(N), const char*, true>
+
+typedef SkTArray<int, true> LengthArray;
+#define PREALLOC_LENGTH_ARRAY(N) SkSTArray<(N), int, true>
+
+// these shouldn't relocate
+typedef GrTAllocator<GrStringBuilder> TempArray;
+#define PREALLOC_TEMP_ARRAY(N) GrSTAllocator<(N), GrStringBuilder>
+
+inline void append_string(const GrStringBuilder& str,
+ StrArray* strings,
+ LengthArray* lengths) {
+ int length = (int) str.size();
+ if (length) {
+ strings->push_back(str.c_str());
+ lengths->push_back(length);
+ }
+ GrAssert(strings->count() == lengths->count());
}
-bool GrGLProgram::CompileFSAndVS(const GrGLInterface* gl,
+inline void append_decls(const VarArray& vars,
+ const GrGLInterface* gl,
+ const char* prefix,
+ StrArray* strings,
+ LengthArray* lengths,
+ TempArray* temp) {
+ expand_decls(vars, gl, prefix, &temp->push_back());
+ append_string(temp->back(), strings, lengths);
+}
+
+}
+
+bool GrGLProgram::CompileShaders(const GrGLInterface* gl,
GLSLVersion glslVersion,
const ShaderCodeSegments& segments,
CachedData* programData) {
+ enum { kPreAllocStringCnt = 8 };
- static const int MAX_STRINGS = 6;
- const char* strings[MAX_STRINGS];
- int lengths[MAX_STRINGS];
- int stringCnt = 0;
- GrStringBuilder attrs;
- GrStringBuilder varyings;
+ PREALLOC_STR_ARRAY(kPreAllocStringCnt) strs;
+ PREALLOC_LENGTH_ARRAY(kPreAllocStringCnt) lengths;
+ PREALLOC_TEMP_ARRAY(kPreAllocStringCnt) temps;
+
GrStringBuilder unis;
- GrStringBuilder fsOutputs;
+ GrStringBuilder inputs;
+ GrStringBuilder outputs;
static const char* gVaryingPrefixes[2][2] = {{"varying", "varying"},
{"out", "in"}};
- const char** varyingPrefixes = glslVersion == k120_GLSLVersion ?
+ const char** varyingPrefixes = k120_GLSLVersion == glslVersion ?
gVaryingPrefixes[0] :
gVaryingPrefixes[1];
- const char* attributePrefix = glslVersion == k120_GLSLVersion ?
+ const char* attributePrefix = k120_GLSLVersion == glslVersion ?
"attribute" :
"in";
- if (segments.fHeader.size()) {
- strings[stringCnt] = segments.fHeader.c_str();
- lengths[stringCnt] = segments.fHeader.size();
- ++stringCnt;
- }
- expand_decls(segments.fVSUnis, gl, "uniform", &unis);
- if (unis.size()) {
- strings[stringCnt] = unis.c_str();
- lengths[stringCnt] = unis.size();
- ++stringCnt;
- }
- expand_decls(segments.fVSAttrs, gl, attributePrefix, &attrs);
- if (attrs.size()) {
- strings[stringCnt] = attrs.c_str();
- lengths[stringCnt] = attrs.size();
- ++stringCnt;
- }
- expand_decls(segments.fVaryings, gl, varyingPrefixes[0], &varyings);
- if (varyings.size()) {
- strings[stringCnt] = varyings.c_str();
- lengths[stringCnt] = varyings.size();
- ++stringCnt;
- }
-
- GrAssert(segments.fVSCode.size());
- strings[stringCnt] = segments.fVSCode.c_str();
- lengths[stringCnt] = segments.fVSCode.size();
- ++stringCnt;
+ append_string(segments.fHeader, &strs, &lengths);
+ append_decls(segments.fVSUnis, gl, "uniform", &strs, &lengths, &temps);
+ append_decls(segments.fVSAttrs, gl, attributePrefix, &strs, &lengths, &temps);
+ append_decls(segments.fVSOutputs, gl, varyingPrefixes[0], &strs, &lengths, &temps);
+ append_string(segments.fVSCode, &strs, &lengths);
#if PRINT_SHADERS
- print_shader(stringCnt, strings, lengths);
+ print_shader(strs.count(), &strs[0], &lengths[0]);
GrPrintf("\n");
#endif
- GrAssert(stringCnt <= MAX_STRINGS);
- programData->fVShaderID = CompileShader(gl, GR_GL_VERTEX_SHADER,
- stringCnt, strings, lengths);
+ programData->fVShaderID =
+ CompileShader(gl, GR_GL_VERTEX_SHADER, strs.count(),
+ &strs[0], &lengths[0]);
if (!programData->fVShaderID) {
return false;
}
-
- stringCnt = 0;
-
- if (segments.fHeader.size()) {
- strings[stringCnt] = segments.fHeader.c_str();
- lengths[stringCnt] = segments.fHeader.size();
- ++stringCnt;
- }
- if (strlen(GrShaderPrecision(gl)) > 1) {
- strings[stringCnt] = GrShaderPrecision(gl);
- lengths[stringCnt] = strlen(GrShaderPrecision(gl));
- ++stringCnt;
- }
- unis.reset();
- expand_decls(segments.fFSUnis, gl, "uniform", &unis);
- if (unis.size()) {
- strings[stringCnt] = unis.c_str();
- lengths[stringCnt] = unis.size();
- ++stringCnt;
- }
- varyings.reset();
- expand_decls(segments.fVaryings, gl, varyingPrefixes[1], &varyings);
- if (varyings.size()) {
- strings[stringCnt] = varyings.c_str();
- lengths[stringCnt] = varyings.size();
- ++stringCnt;
- }
- expand_decls(segments.fFSOutputs, gl, "out", &fsOutputs);
- if (fsOutputs.size()) {
- // We shouldn't have declared outputs on 1.2
- GrAssert(k120_GLSLVersion != glslVersion);
- strings[stringCnt] = fsOutputs.c_str();
- lengths[stringCnt] = fsOutputs.size();
- ++stringCnt;
- }
- if (segments.fFSFunctions.size()) {
- strings[stringCnt] = segments.fFSFunctions.c_str();
- lengths[stringCnt] = segments.fFSFunctions.size();
- ++stringCnt;
+ if (segments.fUsesGS) {
+ strs.reset();
+ lengths.reset();
+ temps.reset();
+ append_string(segments.fHeader, &strs, &lengths);
+ append_string(segments.fGSHeader, &strs, &lengths);
+ append_decls(segments.fGSInputs, gl, "in", &strs, &lengths, &temps);
+ append_decls(segments.fGSOutputs, gl, "out", &strs, &lengths, &temps);
+ append_string(segments.fGSCode, &strs, &lengths);
+#if PRINT_SHADERS
+ print_shader(strs.count(), &strs[0], &lengths[0]);
+ GrPrintf("\n");
+#endif
+ programData->fGShaderID =
+ CompileShader(gl, GR_GL_GEOMETRY_SHADER, strs.count(),
+ &strs[0], &lengths[0]);
+ } else {
+ programData->fGShaderID = 0;
}
- GrAssert(segments.fFSCode.size());
- strings[stringCnt] = segments.fFSCode.c_str();
- lengths[stringCnt] = segments.fFSCode.size();
- ++stringCnt;
+ strs.reset();
+ lengths.reset();
+ temps.reset();
+
+ append_string(segments.fHeader, &strs, &lengths);
+ GrStringBuilder precisionStr(GrShaderPrecision(gl));
+ append_string(precisionStr, &strs, &lengths);
+ append_decls(segments.fFSUnis, gl, "uniform", &strs, &lengths, &temps);
+ append_decls(segments.fFSInputs, gl, varyingPrefixes[1], &strs, &lengths, &temps);
+ // We shouldn't have declared outputs on 1.2
+ GrAssert(k120_GLSLVersion != glslVersion || segments.fFSOutputs.empty());
+ append_decls(segments.fFSOutputs, gl, "out", &strs, &lengths, &temps);
+ append_string(segments.fFSFunctions, &strs, &lengths);
+ append_string(segments.fFSCode, &strs, &lengths);
#if PRINT_SHADERS
- print_shader(stringCnt, strings, lengths);
+ print_shader(strs.count(), &strs[0], &lengths[0]);
GrPrintf("\n");
#endif
- GrAssert(stringCnt <= MAX_STRINGS);
- programData->fFShaderID = CompileShader(gl, GR_GL_FRAGMENT_SHADER,
- stringCnt, strings, lengths);
+ programData->fFShaderID =
+ CompileShader(gl, GR_GL_FRAGMENT_SHADER, strs.count(),
+ &strs[0], &lengths[0]);
if (!programData->fFShaderID) {
return false;
@@ -962,6 +1056,9 @@
const GrGLint& progID = programData->fProgramID;
GR_GL_CALL(gl, AttachShader(progID, programData->fVShaderID));
+ if (programData->fGShaderID) {
+ GR_GL_CALL(gl, AttachShader(progID, programData->fGShaderID));
+ }
GR_GL_CALL(gl, AttachShader(progID, programData->fFShaderID));
if (bindColorOut) {
@@ -1194,24 +1291,27 @@
texelSizeName = segments->fFSUnis.back().getName().c_str();
}
- const char* varyingName;
- GrGLShaderVar* varying = &segments->fVaryings.push_back();
- stage_varying_name(stageNum, varying->accessName());
- varying->setType(float_vector_type(varyingDims));
- varyingName = varying->getName().c_str();
+ const char *varyingVSName, *varyingFSName;
+ append_varying(float_vector_type(varyingDims),
+ "Stage",
+ stageNum,
+ segments,
+ &varyingVSName,
+ &varyingFSName);
if (!matName) {
GrAssert(varyingDims == coordDims);
- segments->fVSCode.appendf("\t%s = %s;\n", varyingName, vsInCoord);
+ segments->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord);
} else {
// varying = texMatrix * texCoord
segments->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n",
- varyingName, matName, vsInCoord,
+ varyingVSName, matName, vsInCoord,
vector_all_coords(varyingDims));
}
const char* radial2ParamsName = NULL;
- const char* radial2VaryingName = NULL;
+ const char *radial2VaryingVSName = NULL;
+ const char *radial2VaryingFSName = NULL;
if (StageDesc::kRadial2Gradient_CoordMapping == desc.fCoordMapping ||
StageDesc::kRadial2GradientDegenerate_CoordMapping == desc.fCoordMapping) {
@@ -1229,18 +1329,18 @@
// part of the quadratic as a varying.
if (varyingDims == coordDims) {
GrAssert(2 == coordDims);
-
- GrGLShaderVar* radial2Varying = &segments->fVaryings.push_back();
- radial2Varying->setType(GrGLShaderVar::kFloat_Type);
- radial2_varying_name(stageNum, radial2Varying->accessName());
- radial2VaryingName = radial2Varying->getName().c_str();
+ append_varying(GrGLShaderVar::kFloat_Type,
+ "Radial2BCoeff",
+ stageNum,
+ segments,
+ &radial2VaryingVSName,
+ &radial2VaryingFSName);
// r2Var = 2 * (r2Parm[2] * varCoord.x - r2Param[3])
const char* r2ParamName = radial2FSParams->getName().c_str();
- const char* r2VarName = radial2Varying->getName().c_str();
segments->fVSCode.appendf("\t%s = 2.0 *(%s[2] * %s.x - %s[3]);\n",
- r2VarName, r2ParamName, varyingName,
- r2ParamName);
+ radial2VaryingVSName, r2ParamName,
+ varyingVSName, r2ParamName);
}
}
@@ -1267,7 +1367,7 @@
locations->fImageIncrementUni = kUseUniform;
float scale = (desc.fKernelWidth - 1) * 0.5f;
segments->fVSCode.appendf("\t%s -= vec2(%g, %g) * %s;\n",
- varyingName, scale, scale,
+ varyingVSName, scale, scale,
imageIncrementName);
}
@@ -1278,7 +1378,7 @@
if (desc.fOptFlags & (StageDesc::kIdentityMatrix_OptFlagBit |
StageDesc::kNoPerspective_OptFlagBit)) {
GrAssert(varyingDims == coordDims);
- fsCoordName = varyingName;
+ fsCoordName = varyingFSName;
} else {
// if we have to do some special op on the varyings to get
// our final tex coords then when in perspective we have to
@@ -1286,16 +1386,16 @@
if (StageDesc::kIdentity_CoordMapping == desc.fCoordMapping &&
StageDesc::kSingle_FetchMode == desc.fFetchMode) {
texFunc.append("Proj");
- fsCoordName = varyingName;
+ fsCoordName = varyingFSName;
} else {
fsCoordName = "inCoord";
fsCoordName.appendS32(stageNum);
segments->fFSCode.appendf("\t%s %s = %s%s / %s%s;\n",
GrGLShaderVar::TypeString(float_vector_type(coordDims)),
fsCoordName.c_str(),
- varyingName,
+ varyingFSName,
vector_nonhomog_coords(varyingDims),
- varyingName,
+ varyingFSName,
vector_homog_coord(varyingDims));
}
}
@@ -1327,7 +1427,7 @@
// otherwise compute it
GrStringBuilder bVar;
if (coordDims == varyingDims) {
- bVar = radial2VaryingName;
+ bVar = radial2VaryingFSName;
GrAssert(2 == varyingDims);
} else {
GrAssert(3 == varyingDims);
@@ -1370,7 +1470,7 @@
// otherwise compute it
GrStringBuilder bVar;
if (coordDims == varyingDims) {
- bVar = radial2VaryingName;
+ bVar = radial2VaryingFSName;
GrAssert(2 == varyingDims);
} else {
GrAssert(3 == varyingDims);