AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove fModulate from GrGLShaderBuilder

Browse Source 
Review URL: https://codereview.appspot.com/6495051/




git-svn-id: http://skia.googlecode.com/svn/trunk@5350 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
bsalomon@google.com 2012-08-30 17:54:14 +00:00
parent 1ea01bf4ce
commit b41b2bc29c
20 changed files with 136 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/effects/SkBlendImageFilter.cpp
View File

@ -263,8 +263,8 @@ void GrGLBlendEffect::emitFS(GrGLShaderBuilder* builder,
const char* bgColor = inputColor;
const char* fgColor = "fgColor";
code->appendf("\t\tvec4 %s = ", fgColor);
builder->emitTextureLookup(samplerName);
code->appendf(";\n");
builder->appendTextureLookup(code, samplerName);
code->append(";\n");
code->appendf("\t\t%s.a = 1.0 - (1.0 - %s.a) * (1.0 - %s.b);\n", outputColor, bgColor, fgColor);
switch (fMode) {
case SkBlendImageFilter::kNormal_Mode:

7
src/effects/SkLightingImageFilter.cpp
View File

@ -1160,7 +1160,7 @@ void GrGLLightingEffect::emitFS(GrGLShaderBuilder* builder,
SkString texCoords;
texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc);
code->appendf("\t\tm[%d] = ", index++);
builder->emitTextureLookup(samplerName, texCoords.c_str());
builder->appendTextureLookup(code, samplerName, texCoords.c_str());
code->appendf(".a;\n");
}
}
@ -1168,11 +1168,12 @@ void GrGLLightingEffect::emitFS(GrGLShaderBuilder* builder,
SkString arg;
arg.appendf("%s * m[4]", surfScale);
fLight->emitSurfaceToLight(builder, code, arg.c_str());
code->appendf(";\n");
code->append(";\n");
code->appendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ",
outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfScale);
fLight->emitLightColor(builder, "surfaceToLight");
code->appendf(")%s;\n", builder->fModulate.c_str());
code->append(");\n");
GrGLSLMulVarBy4f(code, 2, outputColor, inputColor);
}
GrGLProgramStage::StageKey GrGLLightingEffect::GenKey(const GrCustomStage& s,

5
src/effects/SkMagnifierImageFilter.cpp
View File

@ -159,10 +159,11 @@ void GrGLMagnifierEffect::emitFS(GrGLShaderBuilder* state,
code->appendf("\t\tvec2 mix_coord = mix(coord, zoom_coord, weight);\n");
code->appendf("\t\tvec4 output_color = ");
state->emitTextureLookup(samplerName, "mix_coord");
code->appendf(";\n");
state->appendTextureLookup(code, samplerName, "mix_coord");
code->append(";\n");
code->appendf("\t\t%s = output_color;", outputColor);
GrGLSLMulVarBy4f(code, 2, outputColor, inputColor);
}
void GrGLMagnifierEffect::setData(const GrGLUniformManager& uman,

10
src/effects/SkMorphologyImageFilter.cpp
View File

@ -319,11 +319,11 @@ void GrGLMorphologyEffect::emitFS(GrGLShaderBuilder* builder,
const char* func;
switch (fType) {
case GrMorphologyEffect::kErode_MorphologyType:
code->appendf("\t\tvec4 value = vec4(1, 1, 1, 1);\n");
code->appendf("\t\t%s = vec4(1, 1, 1, 1);\n", outputColor);
func = "min";
break;
case GrMorphologyEffect::kDilate_MorphologyType:
code->appendf("\t\tvec4 value = vec4(0, 0, 0, 0);\n");
code->appendf("\t\t%s = vec4(0, 0, 0, 0);\n", outputColor);
func = "max";
break;
default:
@ -336,12 +336,12 @@ void GrGLMorphologyEffect::emitFS(GrGLShaderBuilder* builder,
code->appendf("\t\tvec2 coord = %s - %d.0 * %s;\n",
builder->defaultTexCoordsName(), fRadius, imgInc);
code->appendf("\t\tfor (int i = 0; i < %d; i++) {\n", this->width());
code->appendf("\t\t\tvalue = %s(value, ", func);
builder->emitTextureLookup(samplerName, "coord");
code->appendf("\t\t\t%s = %s(%s, ", outputColor, func, outputColor);
builder->appendTextureLookup(&builder->fFSCode, samplerName, "coord");
code->appendf(");\n");
code->appendf("\t\t\tcoord += %s;\n", imgInc);
code->appendf("\t\t}\n");
code->appendf("\t\t%s = value%s;\n", outputColor, builder->fModulate.c_str());
GrGLSLMulVarBy4f(code, 2, outputColor, inputColor);
}
GrGLProgramStage::StageKey GrGLMorphologyEffect::GenKey(const GrCustomStage& s,

15
src/effects/gradients/SkGradientShader.cpp
View File

@ -699,14 +699,19 @@ void GrGLGradientStage::setData(const GrGLUniformManager& uman,
}
void GrGLGradientStage::emitColorLookup(GrGLShaderBuilder* builder,
const char* tName,
const char* gradientTValue,
const char* outputColor,
const char* inputColor,
const char* samplerName) {
builder->fFSCode.appendf("\tvec2 coord = vec2(%s, %s);\n",
tName,
builder->getUniformVariable(fFSYUni).c_str());
builder->emitTextureLookupAndModulate(outputColor, samplerName, "coord");
SkString* code = &builder->fFSCode;
code->appendf("\tvec2 coord = vec2(%s, %s);\n",
gradientTValue,
builder->getUniformVariable(fFSYUni).c_str());
GrGLSLMulVarBy4f(code, 1, outputColor, inputColor);
code->appendf("\t%s = ", outputColor);
builder->appendTextureLookupAndModulate(code, inputColor, samplerName, "coord");
code->append(";\n");
}
/////////////////////////////////////////////////////////////////////

7
src/effects/gradients/SkGradientShaderPriv.h
View File

@ -287,8 +287,11 @@ public:
// emit code that gets a fragment's color from an expression for t; for now
// this always uses the texture, but for simpler cases we'll be able to lerp
void emitColorLookup(GrGLShaderBuilder* builder, const char* t,
const char* outputColor, const char* samplerName);
void emitColorLookup(GrGLShaderBuilder* builder,
const char* gradientTValue,
const char* outputColor,
const char* inputColor,
const char* samplerName);
private:

2
src/effects/gradients/SkLinearGradient.cpp
View File

@ -553,7 +553,7 @@ void GrGLLinearGradient::emitFS(GrGLShaderBuilder* builder,
const char* samplerName) {
SkString t;
t.printf("%s.x", builder->defaultTexCoordsName());
this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
}
/////////////////////////////////////////////////////////////////////

2
src/effects/gradients/SkRadialGradient.cpp
View File

@ -553,7 +553,7 @@ void GrGLRadialGradient::emitFS(GrGLShaderBuilder* builder,
const char* samplerName) {
SkString t;
t.printf("length(%s.xy)", builder->defaultTexCoordsName());
this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
}
/////////////////////////////////////////////////////////////////////

2
src/effects/gradients/SkSweepGradient.cpp
View File

@ -459,7 +459,7 @@ void GrGLSweepGradient::emitFS(GrGLShaderBuilder* builder,
SkString t;
t.printf("atan(- %s.y, - %s.x) * 0.1591549430918 + 0.5",
builder->defaultTexCoordsName(), builder->defaultTexCoordsName());
this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
}
/////////////////////////////////////////////////////////////////////

6
src/effects/gradients/SkTwoPointConicalGradient.cpp
View File

@ -593,7 +593,7 @@ void GrGLConical2Gradient::emitFS(GrGLShaderBuilder* builder,
p5.c_str(), p3.c_str());
code->appendf("\t\t");
this->emitColorLookup(builder, tName.c_str(), outputColor, samplerName);
this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplerName);
// otherwise, if r(t) for the larger root was <= 0, try the other root
code->appendf("\t\t} else {\n");
@ -605,7 +605,7 @@ void GrGLConical2Gradient::emitFS(GrGLShaderBuilder* builder,
tName.c_str(), p5.c_str(), p3.c_str());
code->appendf("\t\t\t");
this->emitColorLookup(builder, tName.c_str(), outputColor, samplerName);
this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplerName);
// end if (r(t) > 0) for smaller root
code->appendf("\t\t\t}\n");
@ -623,7 +623,7 @@ void GrGLConical2Gradient::emitFS(GrGLShaderBuilder* builder,
code->appendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
p5.c_str(), p3.c_str());
code->appendf("\t");
this->emitColorLookup(builder, tName.c_str(), outputColor, samplerName);
this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplerName);
code->appendf("\t}\n");
}
}

2
src/effects/gradients/SkTwoPointRadialGradient.cpp
View File

@ -601,7 +601,7 @@ void GrGLRadial2Gradient::emitFS(GrGLShaderBuilder* builder,
t.printf("-%s / %s", cName.c_str(), bVar.c_str());
}
this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
}
void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman,

24
src/gpu/effects/GrConfigConversionEffect.cpp
View File

@ -23,37 +23,39 @@ public:
const char* outputColor,
const char* inputColor,
const char* samplerName) SK_OVERRIDE {
builder->fFSCode.append("\tvec4 tempColor;\n");
builder->emitTextureLookupAndModulate("tempColor", samplerName);
builder->fFSCode.appendf("\t\t%s = ", outputColor);
builder->appendTextureLookup(&builder->fFSCode, samplerName);
builder->fFSCode.appendf("%s;\n", builder->fSwizzle.c_str());
if (GrConfigConversionEffect::kNone_PMConversion == fPMConversion) {
GrAssert(fSwapRedAndBlue);
builder->fFSCode.appendf("\t%s = tempColor.bgra;\n", outputColor);
builder->fFSCode.appendf("\t%s = %s.bgra;\n", outputColor, outputColor);
} else {
const char* swiz = fSwapRedAndBlue ? "bgr" : "rgb";
switch (fPMConversion) {
case GrConfigConversionEffect::kMulByAlpha_RoundUp_PMConversion:
builder->fFSCode.appendf(
"\t%s = vec4(ceil(tempColor.%s*tempColor.a*255.0)/255.0, tempColor.a);\n",
outputColor, swiz);
"\t\t%s = vec4(ceil(%s.%s * %s.a * 255.0) / 255.0, %s.a);\n",
outputColor, outputColor, swiz, outputColor, outputColor);
break;
case GrConfigConversionEffect::kMulByAlpha_RoundDown_PMConversion:
builder->fFSCode.appendf(
"\t%s = vec4(floor(tempColor.%s*tempColor.a*255.0)/255.0, tempColor.a);\n",
outputColor, swiz);
"\t\t%s = vec4(floor(%s.%s * %s.a * 255.0) / 255.0, %s.a);\n",
outputColor, outputColor, swiz, outputColor, outputColor);
break;
case GrConfigConversionEffect::kDivByAlpha_RoundUp_PMConversion:
builder->fFSCode.appendf("\t%s = tempColor.a <= 0.0 ? vec4(0,0,0,0) : vec4(ceil(tempColor.%s / tempColor.a * 255.0)/255.0, tempColor.a);\n",
outputColor, swiz);
builder->fFSCode.appendf("\t\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(ceil(%s.%s / %s.a * 255.0) / 255.0, %s.a);\n",
outputColor, outputColor, outputColor, swiz, outputColor, outputColor);
break;
case GrConfigConversionEffect::kDivByAlpha_RoundDown_PMConversion:
builder->fFSCode.appendf("\t%s = tempColor.a <= 0.0 ? vec4(0,0,0,0) : vec4(floor(tempColor.%s / tempColor.a * 255.0)/255.0, tempColor.a);\n",
outputColor, swiz);
builder->fFSCode.appendf("\t\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(floor(%s.%s / %s.a * 255.0) / 255.0, %s.a);\n",
outputColor, outputColor, outputColor, swiz, outputColor, outputColor);
break;
default:
GrCrash("Unknown conversion op.");
break;
}
}
GrGLSLMulVarBy4f(&builder->fFSCode, 2, outputColor, inputColor);
}
static inline StageKey GenKey(const GrCustomStage& s, const GrGLCaps&) {

8
src/gpu/effects/GrConvolutionEffect.cpp
View File

@ -84,15 +84,11 @@ void GrGLConvolutionEffect::emitFS(GrGLShaderBuilder* builder,
index.appendS32(i);
kernel.appendArrayAccess(index.c_str(), &kernelIndex);
code->appendf("\t\t%s += ", outputColor);
builder->emitTextureLookup(samplerName, "coord");
builder->appendTextureLookup(&builder->fFSCode, samplerName, "coord");
code->appendf(" * %s;\n", kernelIndex.c_str());
code->appendf("\t\tcoord += %s;\n", imgInc);
}
if (builder->fModulate.size()) {
code->appendf("\t\t%s = %s%s;\n", outputColor, outputColor,
builder->fModulate.c_str());
}
GrGLSLMulVarBy4f(&builder->fFSCode, 2, outputColor, inputColor);
}
void GrGLConvolutionEffect::setData(const GrGLUniformManager& uman,

4
src/gpu/effects/GrSingleTextureEffect.cpp
View File

@ -23,7 +23,9 @@ public:
const char* outputColor,
const char* inputColor,
const char* samplerName) SK_OVERRIDE {
builder->emitTextureLookupAndModulate(outputColor, samplerName);
builder->fFSCode.appendf("\t%s = ", outputColor);
builder->appendTextureLookupAndModulate(&builder->fFSCode, inputColor, samplerName);
builder->fFSCode.append(";\n");
}
static inline StageKey GenKey(const GrCustomStage&, const GrGLCaps&) { return 0; }

4
src/gpu/effects/GrTextureDomainEffect.cpp
View File

@ -55,7 +55,9 @@ void GrGLTextureDomainEffect::emitFS(GrGLShaderBuilder* builder,
builder->getUniformCStr(fNameUni),
builder->getUniformCStr(fNameUni));
builder->emitTextureLookupAndModulate(outputColor, samplerName, "clampCoord");
builder->fFSCode.appendf("\t%s = ", outputColor);
builder->appendTextureLookupAndModulate(&builder->fFSCode, inputColor, samplerName, "clampCoord");
builder->fFSCode.append(";\n");
}
void GrGLTextureDomainEffect::setData(const GrGLUniformManager& uman,

1
src/gpu/gl/GrGLProgram.cpp
View File

@ -987,7 +987,6 @@ void GrGLProgram::genStageCode(int stageNum,
builder->fVSCode.appendf("\t}\n");
builder->computeSwizzle(desc.fInConfigFlags);
builder->computeModulate(fsInColor);
// Enclose custom code in a block to avoid namespace conflicts
builder->fFSCode.appendf("\t{ // stage %d %s \n",

38
src/gpu/gl/GrGLSL.cpp
View File

@ -115,6 +115,7 @@ GrSLConstantVec GrGLSLModulate4f(SkString* outAppend,
outAppend->append(GrGLSLZerosVecf(4));
return kZeros_GrSLConstantVec;
} else {
// both inputs are ones vectors
outAppend->append(GrGLSLOnesVecf(4));
return kOnes_GrSLConstantVec;
}
@ -142,6 +143,43 @@ GrSLConstantVec GrGLSLModulate4f(SkString* outAppend,
}
}
namespace {
void append_tabs(SkString* outAppend, int tabCnt) {
static const char kTabs[] = "\t\t\t\t\t\t\t\t";
while (tabCnt) {
int cnt = GrMin((int)GR_ARRAY_COUNT(kTabs), tabCnt);
outAppend->append(kTabs, cnt);
tabCnt -= cnt;
}
}
}
GrSLConstantVec GrGLSLMulVarBy4f(SkString* outAppend,
int tabCnt,
const char* vec4VarName,
const char* mulFactor,
GrSLConstantVec mulFactorDefault) {
bool haveFactor = NULL != mulFactor && '\0' != *mulFactor;
GrAssert(NULL != outAppend);
GrAssert(NULL != vec4VarName);
GrAssert(kNone_GrSLConstantVec != mulFactorDefault || haveFactor);
if (!haveFactor) {
if (kOnes_GrSLConstantVec == mulFactorDefault) {
return kNone_GrSLConstantVec;
} else {
GrAssert(kZeros_GrSLConstantVec == mulFactorDefault);
append_tabs(outAppend, tabCnt);
outAppend->appendf("%s = vec4(0, 0, 0, 0);\n", vec4VarName);
return kZeros_GrSLConstantVec;
}
}
append_tabs(outAppend, tabCnt);
outAppend->appendf("%s *= %s;\n", vec4VarName, mulFactor);
return kNone_GrSLConstantVec;
}
GrSLConstantVec GrGLSLAdd4f(SkString* outAppend,
const char* in0,
const char* in1,

13
src/gpu/gl/GrGLSL.h
View File

@ -144,6 +144,19 @@ GrSLConstantVec GrGLSLModulate4f(SkString* outAppend,
GrSLConstantVec default0 = kOnes_GrSLConstantVec,
GrSLConstantVec default1 = kOnes_GrSLConstantVec);
/**
* Does an inplace mul, *=, of vec4VarName by mulFactor. If mulFactorDefault is not kNone then
* mulFactor may be either "" or NULL. In this case either nothing will be appened (kOnes) or an
* assignment of vec(0,0,0,0) will be appended (kZeros). The assignment is prepended by tabCnt tabs.
* A semicolon and newline are added after the assignment. (TODO: Remove tabCnt when we auto-insert
* tabs to custom stage-generated lines.) If a zeros vec is assigned then the return value is
* kZeros, otherwise kNone.
*/
GrSLConstantVec GrGLSLMulVarBy4f(SkString* outAppend,
int tabCnt,
const char* vec4VarName,
const char* mulFactor,
GrSLConstantVec mulFactorDefault = kOnes_GrSLConstantVec);
/**
* Produces a string that is the result of adding two inputs. The inputs must be vec4 or float.

34
src/gpu/gl/GrGLShaderBuilder.cpp
View File

@ -96,14 +96,6 @@ void GrGLShaderBuilder::computeSwizzle(uint32_t configFlags) {
}
}
void GrGLShaderBuilder::computeModulate(const char* fsInColor) {
if (NULL != fsInColor) {
fModulate.printf(" * %s", fsInColor);
} else {
fModulate.reset();
}
}
void GrGLShaderBuilder::setupTextureAccess(const char* varyingFSName, GrSLType varyingType) {
// FIXME: We don't know how the custom stage will manipulate the coords. So we give up on using
// projective texturing and always give the stage 2D coords. This will be fixed when custom
@ -130,23 +122,27 @@ void GrGLShaderBuilder::setupTextureAccess(const char* varyingFSName, GrSLType v
}
}
void GrGLShaderBuilder::emitTextureLookup(const char* samplerName,
const char* coordName,
GrSLType varyingType) {
void GrGLShaderBuilder::appendTextureLookup(SkString* out,
const char* samplerName,
const char* coordName,
GrSLType varyingType) const {
if (NULL == coordName) {
coordName = fDefaultTexCoordsName.c_str();
varyingType = kVec2f_GrSLType;
}
fFSCode.appendf("%s(%s, %s)", sample_function_name(varyingType), samplerName, coordName);
out->appendf("%s(%s, %s)", sample_function_name(varyingType), samplerName, coordName);
}
void GrGLShaderBuilder::emitTextureLookupAndModulate(const char* outColor,
const char* samplerName,
const char* coordName,
GrSLType varyingType) {
fFSCode.appendf("\t%s = ", outColor);
this->emitTextureLookup(samplerName, coordName, varyingType);
fFSCode.appendf("%s%s;\n", fSwizzle.c_str(), fModulate.c_str());
void GrGLShaderBuilder::appendTextureLookupAndModulate(SkString* out,
const char* modulation,
const char* samplerName,
const char* coordName,
GrSLType varyingType) const {
GrAssert(NULL != out);
SkString lookup;
this->appendTextureLookup(&lookup, samplerName, coordName, varyingType);
GrGLSLModulate4f(out, modulation, lookup.c_str());
out->append(fSwizzle.c_str());
}
void GrGLShaderBuilder::emitCustomTextureLookup(const GrTextureAccess& textureAccess,

25
src/gpu/gl/GrGLShaderBuilder.h
View File

@ -32,7 +32,6 @@ public:
GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&);
void computeSwizzle(uint32_t configFlags);
void computeModulate(const char* fsInColor);
/** Determines whether we should use texture2D() or texture2Dproj(), and if an explicit divide
is required for the sample coordinates, creates the new variable and emits the code to
@ -42,17 +41,20 @@ public:
/** texture2D(samplerName, coordName), with projection if necessary; if coordName is not
specified, uses fSampleCoords. coordType must either be Vec2f or Vec3f. The latter is
interpreted as projective texture coords. */
void emitTextureLookup(const char* samplerName,
const char* coordName = NULL,
GrSLType coordType = kVec2f_GrSLType);
void appendTextureLookup(SkString* out,
const char* samplerName,
const char* coordName = NULL,
GrSLType coordType = kVec2f_GrSLType) const;
/** sets outColor to results of texture lookup, with swizzle, and/or modulate as necessary. If
coordName is NULL then it as if defaultTexCoordsName() was passed. coordType must be either
kVec2f or kVec3f. */
void emitTextureLookupAndModulate(const char* outColor,
const char* samplerName,
const char* coordName = NULL,
GrSLType coordType = kVec2f_GrSLType);
/** appends a texture lookup, with swizzle as necessary. If coordName is NULL then it as if
defaultTexCoordsName() was passed. coordType must be either kVec2f or kVec3f. If modulateVar
is not NULL or "" then the texture lookup will be modulated by it. modulation must refer to
be expression that evaluates to a float or vec4. */
void appendTextureLookupAndModulate(SkString* out,
const char* modulation,
const char* samplerName,
const char* coordName = NULL,
GrSLType varyingType = kVec2f_GrSLType) const;
/** Gets the name of the default texture coords which are always kVec2f */
const char* defaultTexCoordsName() const { return fDefaultTexCoordsName.c_str(); }
@ -171,7 +173,6 @@ public:
//@{
SkString fSwizzle;
SkString fModulate;
//@}