GrGLProgram::StageUniLocations* locations,
const char** radial2VaryingVSName,
const char** radial2VaryingFSName,
- const char* varyingVSName,
- int varyingDims, int coordDims) {
+ const char* varyingVSName) {
GrGLShaderVar* radial2FSParams = &segments->fFSUnis.push_back();
radial2FSParams->setType(kFloat_GrSLType);
// for radial grads without perspective we can pass the linear
// part of the quadratic as a varying.
- if (varyingDims == coordDims) {
- GrAssert(2 == coordDims);
+ if (segments->fVaryingDims == segments->fCoordDims) {
+ GrAssert(2 == segments->fCoordDims);
segments->appendVarying(kFloat_GrSLType,
"Radial2BCoeff",
stageNum,
const char* radial2VaryingFSName,
GrGLShaderVar* radial2Params,
GrStringBuilder& sampleCoords,
- GrStringBuilder& fsCoordName,
- int varyingDims,
- int coordDims) {
+ GrStringBuilder& fsCoordName) {
GrStringBuilder cName("c");
GrStringBuilder ac4Name("ac4");
GrStringBuilder rootName("root");
// if we were able to interpolate the linear component bVar is the varying
// otherwise compute it
GrStringBuilder bVar;
- if (coordDims == varyingDims) {
+ if (segments->fCoordDims == segments->fVaryingDims) {
bVar = radial2VaryingFSName;
- GrAssert(2 == varyingDims);
+ GrAssert(2 == segments->fVaryingDims);
} else {
- GrAssert(3 == varyingDims);
+ GrAssert(3 == segments->fVaryingDims);
bVar = "b";
bVar.appendS32(stageNum);
segments->fFSCode.appendf("\tfloat %s = 2.0 * (%s * %s.x - %s);\n",
const char* radial2VaryingFSName,
GrGLShaderVar* radial2Params,
GrStringBuilder& sampleCoords,
- GrStringBuilder& fsCoordName,
- int varyingDims,
- int coordDims) {
+ GrStringBuilder& fsCoordName) {
GrStringBuilder cName("c");
cName.appendS32(stageNum);
// if we were able to interpolate the linear component bVar is the varying
// otherwise compute it
GrStringBuilder bVar;
- if (coordDims == varyingDims) {
+ if (segments->fCoordDims == segments->fVaryingDims) {
bVar = radial2VaryingFSName;
- GrAssert(2 == varyingDims);
+ GrAssert(2 == segments->fVaryingDims);
} else {
- GrAssert(3 == varyingDims);
+ GrAssert(3 == segments->fVaryingDims);
bVar = "b";
bVar.appendS32(stageNum);
segments->fFSCode.appendf("\tfloat %s = 2.0 * (%s * %s.x - %s);\n",
const char* fsOutColor,
GrStringBuilder& texFunc,
GrStringBuilder& modulate,
- bool complexCoord,
- int coordDims) {
+ bool complexCoord) {
locations->fNormalizedTexelSizeUni = kUseUniform;
if (complexCoord) {
// assign the coord to a var rather than compute 4x.
GrStringBuilder coordVar("tCoord");
coordVar.appendS32(stageNum);
segments->fFSCode.appendf("\t%s %s = %s;\n",
- float_vector_type_str(coordDims),
+ float_vector_type_str(segments->fCoordDims),
coordVar.c_str(), sampleCoords->c_str());
*sampleCoords = coordVar;
}
- GrAssert(2 == coordDims);
+ GrAssert(2 == segments->fCoordDims);
GrStringBuilder accumVar("accum");
accumVar.appendS32(stageNum);
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);
GrAssert((desc.fInConfigFlags & StageDesc::kInConfigBitMask) ==
desc.fInConfigFlags);
- // First decide how many coords are needed to access the texture
- // Right now it's always 2 but we could start using 1D textures for
- // gradients.
- static const int coordDims = 2;
- int varyingDims;
-
/// Vertex Shader Stuff
if (NULL != customStage) {
// and whether the varying needs a perspective coord.
const char* matName = NULL;
if (desc.fOptFlags & StageDesc::kIdentityMatrix_OptFlagBit) {
- varyingDims = coordDims;
+ segments->fVaryingDims = segments->fCoordDims;
} else {
GrGLShaderVar* mat;
mat = &segments->fVSUnis.push_back();
matName = mat->getName().c_str();
if (desc.fOptFlags & StageDesc::kNoPerspective_OptFlagBit) {
- varyingDims = coordDims;
+ segments->fVaryingDims = segments->fCoordDims;
} else {
- varyingDims = coordDims + 1;
+ segments->fVaryingDims = segments->fCoordDims + 1;
}
}
+ GrAssert(segments->fVaryingDims > 0);
segments->fFSUnis.push_back().set(kSampler2D_GrSLType,
GrGLShaderVar::kUniform_TypeModifier, "");
}
const char *varyingVSName, *varyingFSName;
- segments->appendVarying(GrSLFloatVectorType(varyingDims),
+ segments->appendVarying(GrSLFloatVectorType(segments->fVaryingDims),
"Stage",
stageNum,
&varyingVSName,
&varyingFSName);
if (!matName) {
- GrAssert(varyingDims == coordDims);
+ GrAssert(segments->fVaryingDims == segments->fCoordDims);
segments->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord);
} else {
// varying = texMatrix * texCoord
segments->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n",
varyingVSName, matName, vsInCoord,
- vector_all_coords(varyingDims));
+ vector_all_coords(segments->fVaryingDims));
}
GrGLShaderVar* radial2Params = NULL;
locations,
&radial2VaryingVSName,
&radial2VaryingFSName,
- varyingVSName,
- varyingDims, coordDims);
+ varyingVSName);
}
GrGLShaderVar* kernel = NULL;
GrStringBuilder texFunc("texture2D");
if (desc.fOptFlags & (StageDesc::kIdentityMatrix_OptFlagBit |
StageDesc::kNoPerspective_OptFlagBit)) {
- GrAssert(varyingDims == coordDims);
+ GrAssert(segments->fVaryingDims == segments->fCoordDims);
fsCoordName = varyingFSName;
} else {
// if we have to do some special op on the varyings to get
fsCoordName = "inCoord";
fsCoordName.appendS32(stageNum);
segments->fFSCode.appendf("\t%s %s = %s%s / %s%s;\n",
- GrGLShaderVar::TypeString(GrSLFloatVectorType(coordDims)),
+ GrGLShaderVar::TypeString(GrSLFloatVectorType(segments->fCoordDims)),
fsCoordName.c_str(),
varyingFSName,
- GrGLSLVectorNonhomogCoords(varyingDims),
+ GrGLSLVectorNonhomogCoords(segments->fVaryingDims),
varyingFSName,
- GrGLSLVectorHomogCoord(varyingDims));
+ GrGLSLVectorHomogCoord(segments->fVaryingDims));
}
}
complexCoord = genRadial2GradientCoordMapping(
stageNum, segments,
radial2VaryingFSName, radial2Params,
- sampleCoords, fsCoordName,
- varyingDims, coordDims);
-
+ sampleCoords, fsCoordName);
break;
case StageDesc::kRadial2GradientDegenerate_CoordMapping:
complexCoord = genRadial2GradientDegenerateCoordMapping(
stageNum, segments,
radial2VaryingFSName, radial2Params,
- sampleCoords, fsCoordName,
- varyingDims, coordDims);
+ sampleCoords, fsCoordName);
break;
};
GrGLShaderVar::kUniform_TypeModifier, texDomainName);
GrStringBuilder coordVar("clampCoord");
segments->fFSCode.appendf("\t%s %s = clamp(%s, %s.xy, %s.zw);\n",
- float_vector_type_str(coordDims),
+ float_vector_type_str(segments->fCoordDims),
coordVar.c_str(),
sampleCoords.c_str(),
texDomainName.c_str(),
GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
gen2x2FS(stageNum, segments, locations, &sampleCoords,
samplerName, texelSizeName, swizzle, fsOutColor,
- texFunc, modulate, complexCoord, coordDims);
+ texFunc, modulate, complexCoord);
break;
case StageDesc::kConvolution_FetchMode:
GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
GrStringBuilder fragmentShader;
fsCoordName = customStage->emitTextureSetup(
&fragmentShader, sampleCoords.c_str(),
- stageNum, coordDims, varyingDims);
+ stageNum, segments);
customStage->emitFS(&fragmentShader, fsOutColor, fsInColor,
samplerName, fsCoordName.c_str());