Index: src/gpu/gl/GrGLProgram.cpp |
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp |
index 19ddf970216eba8d50228abe9793e22c1c9561e6..93ed5d77850f48e1e38362310fc54657ba3774df 100644 |
--- a/src/gpu/gl/GrGLProgram.cpp |
+++ b/src/gpu/gl/GrGLProgram.cpp |
@@ -115,118 +115,6 @@ void GrGLProgram::overrideBlend(GrBlendCoeff* srcCoeff, |
} |
} |
-namespace { |
-// given two blend coefficients determine whether the src |
-// and/or dst computation can be omitted. |
-inline void need_blend_inputs(SkXfermode::Coeff srcCoeff, |
- SkXfermode::Coeff dstCoeff, |
- bool* needSrcValue, |
- bool* needDstValue) { |
- if (SkXfermode::kZero_Coeff == srcCoeff) { |
- switch (dstCoeff) { |
- // these all read the src |
- case SkXfermode::kSC_Coeff: |
- case SkXfermode::kISC_Coeff: |
- case SkXfermode::kSA_Coeff: |
- case SkXfermode::kISA_Coeff: |
- *needSrcValue = true; |
- break; |
- default: |
- *needSrcValue = false; |
- break; |
- } |
- } else { |
- *needSrcValue = true; |
- } |
- if (SkXfermode::kZero_Coeff == dstCoeff) { |
- switch (srcCoeff) { |
- // these all read the dst |
- case SkXfermode::kDC_Coeff: |
- case SkXfermode::kIDC_Coeff: |
- case SkXfermode::kDA_Coeff: |
- case SkXfermode::kIDA_Coeff: |
- *needDstValue = true; |
- break; |
- default: |
- *needDstValue = false; |
- break; |
- } |
- } else { |
- *needDstValue = true; |
- } |
-} |
- |
-/** |
- * Create a blend_coeff * value string to be used in shader code. Sets empty |
- * string if result is trivially zero. |
- */ |
-inline void blend_term_string(SkString* str, SkXfermode::Coeff coeff, |
- const char* src, const char* dst, |
- const char* value) { |
- switch (coeff) { |
- case SkXfermode::kZero_Coeff: /** 0 */ |
- *str = ""; |
- break; |
- case SkXfermode::kOne_Coeff: /** 1 */ |
- *str = value; |
- break; |
- case SkXfermode::kSC_Coeff: |
- str->printf("(%s * %s)", src, value); |
- break; |
- case SkXfermode::kISC_Coeff: |
- str->printf("((%s - %s) * %s)", GrGLSLExpr<4>::onesStr(), src, value); |
- break; |
- case SkXfermode::kDC_Coeff: |
- str->printf("(%s * %s)", dst, value); |
- break; |
- case SkXfermode::kIDC_Coeff: |
- str->printf("((%s - %s) * %s)", GrGLSLExpr<4>::onesStr(), dst, value); |
- break; |
- case SkXfermode::kSA_Coeff: /** src alpha */ |
- str->printf("(%s.a * %s)", src, value); |
- break; |
- case SkXfermode::kISA_Coeff: /** inverse src alpha (i.e. 1 - sa) */ |
- str->printf("((1.0 - %s.a) * %s)", src, value); |
- break; |
- case SkXfermode::kDA_Coeff: /** dst alpha */ |
- str->printf("(%s.a * %s)", dst, value); |
- break; |
- case SkXfermode::kIDA_Coeff: /** inverse dst alpha (i.e. 1 - da) */ |
- str->printf("((1.0 - %s.a) * %s)", dst, value); |
- break; |
- default: |
- GrCrash("Unexpected xfer coeff."); |
- break; |
- } |
-} |
-/** |
- * Adds a line to the fragment shader code which modifies the color by |
- * the specified color filter. |
- */ |
-void add_color_filter(GrGLShaderBuilder* builder, |
- const char * outputVar, |
- SkXfermode::Coeff uniformCoeff, |
- SkXfermode::Coeff colorCoeff, |
- const char* filterColor, |
- const char* inColor) { |
- SkString colorStr, constStr; |
- blend_term_string(&colorStr, colorCoeff, filterColor, inColor, inColor); |
- blend_term_string(&constStr, uniformCoeff, filterColor, inColor, filterColor); |
- SkASSERT(!(colorStr.isEmpty() && constStr.isEmpty())); |
- |
- GrGLSLExpr<4> result; |
- if (colorStr.isEmpty()) { |
- result = constStr; |
- } else if (constStr.isEmpty()) { |
- result = colorStr; |
- } else { |
- result = GrGLSLAddf<4,4>(colorStr, constStr); |
- } |
- |
- builder->fsCodeAppendf("\t%s = %s;\n", outputVar, result.c_str()); |
-} |
-} |
- |
GrGLSLExpr<4> GrGLProgram::genInputColor(GrGLShaderBuilder* builder) { |
switch (fDesc.getHeader().fColorInput) { |
case GrGLProgramDesc::kAttribute_ColorInput: { |
@@ -422,28 +310,18 @@ bool GrGLProgram::genProgram(const GrEffectStage* colorStages[], |
const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader(); |
bool hasExplicitLocalCoords = -1 != header.fLocalCoordAttributeIndex; |
- // Get the coeffs for the Mode-based color filter, determine if color is needed. |
- SkXfermode::Coeff colorCoeff; |
- SkXfermode::Coeff filterColorCoeff; |
- SkAssertResult( |
- SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>(header.fColorFilterXfermode), |
- &filterColorCoeff, |
- &colorCoeff)); |
- bool needColor, needFilterColor; |
- need_blend_inputs(filterColorCoeff, colorCoeff, &needFilterColor, &needColor); |
- |
// Create the GL effects. |
bool hasVertexShaderEffects = false; |
- |
- SkTArray<GrDrawEffect> colorDrawEffects(needColor ? fDesc.numColorEffects() : 0); |
- if (needColor) { |
+ bool willUseInputColor = false; |
+ SkTArray<GrDrawEffect> colorDrawEffects(fDesc.numColorEffects()); |
+ if (fDesc.numColorEffects() > 0) { |
this->buildGLEffects(&GrGLProgram::fColorEffects, colorStages, fDesc.numColorEffects(), |
- hasExplicitLocalCoords, &colorDrawEffects, &hasVertexShaderEffects); |
+ hasExplicitLocalCoords, &colorDrawEffects, &hasVertexShaderEffects, &willUseInputColor); |
} |
SkTArray<GrDrawEffect> coverageDrawEffects(fDesc.numCoverageEffects()); |
this->buildGLEffects(&GrGLProgram::fCoverageEffects, coverageStages, fDesc.numCoverageEffects(), |
- hasExplicitLocalCoords, &coverageDrawEffects, &hasVertexShaderEffects); |
+ hasExplicitLocalCoords, &coverageDrawEffects, &hasVertexShaderEffects, &willUseInputColor); |
GrGLShaderBuilder builder(fGpu->ctxInfo(), fUniformManager, fDesc, hasVertexShaderEffects); |
@@ -479,7 +357,12 @@ bool GrGLProgram::genProgram(const GrEffectStage* colorStages[], |
} |
// incoming color to current stage being processed. |
- GrGLSLExpr<4> inColor = this->genInputColor(&builder); |
+ GrGLSLExpr<4> inColor; |
+ if (willUseInputColor || (0 == fDesc.numColorEffects() && 0 == fDesc.numCoverageEffects())) { |
+ inColor = this->genInputColor(&builder); |
+ } else { |
+ inColor = GrGLSLExpr<4>::Ones(); |
+ } |
// used in order for builder to return the per-stage uniform handles. |
typedef SkTArray<GrGLUniformManager::UniformHandle, true>* UniHandleArrayPtr; |
@@ -487,7 +370,7 @@ bool GrGLProgram::genProgram(const GrEffectStage* colorStages[], |
SkAutoTArray<UniHandleArrayPtr> effectUniformArrays(maxColorOrCovEffectCnt); |
SkAutoTArray<GrGLEffect*> glEffects(maxColorOrCovEffectCnt); |
- if (needColor) { |
+ if (fDesc.numColorEffects()) { |
for (int e = 0; e < fDesc.numColorEffects(); ++e) { |
glEffects[e] = fColorEffects[e].fGLEffect; |
effectUniformArrays[e] = &fColorEffects[e].fSamplerUnis; |
@@ -501,20 +384,6 @@ bool GrGLProgram::genProgram(const GrEffectStage* colorStages[], |
effectUniformArrays.get()); |
} |
- // Insert the color filter. This will soon be replaced by a color effect. |
- if (SkXfermode::kDst_Mode != header.fColorFilterXfermode) { |
- const char* colorFilterColorUniName = NULL; |
- fUniformHandles.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_Visibility, |
- kVec4f_GrSLType, "FilterColor", |
- &colorFilterColorUniName); |
- |
- builder.fsCodeAppend("\tvec4 filteredColor;\n"); |
- |
- add_color_filter(&builder, "filteredColor", filterColorCoeff, |
- colorCoeff, colorFilterColorUniName, inColor.c_str()); |
- inColor = "filteredColor"; |
- } |
- |
/////////////////////////////////////////////////////////////////////////// |
// compute the partial coverage |
GrGLSLExpr<4> inCoverage = this->genInputCoverage(&builder); |
@@ -531,6 +400,10 @@ bool GrGLProgram::genProgram(const GrEffectStage* colorStages[], |
&inCoverage, |
effectUniformArrays.get()); |
+ if (!inColor.isValid()) { |
bsalomon
2013/09/27 13:59:39
What's this about?
|
+ |
+ } |
+ |
// discard if coverage is zero |
if (header.fDiscardIfZeroCoverage && !inCoverage.isOnes()) { |
if (inCoverage.isZeros()) { |
@@ -621,7 +494,8 @@ void GrGLProgram::buildGLEffects(SkTArray<EffectAndSamplers> GrGLProgram::* effe |
int count, |
bool hasExplicitLocalCoords, |
SkTArray<GrDrawEffect>* drawEffects, |
- bool* hasVertexShaderEffects) { |
+ bool* hasVertexShaderEffects, |
+ bool* willUseInputColor) { |
for (int e = 0; e < count; ++e) { |
SkASSERT(NULL != stages[e] && NULL != stages[e]->getEffect()); |
@@ -636,6 +510,10 @@ void GrGLProgram::buildGLEffects(SkTArray<EffectAndSamplers> GrGLProgram::* effe |
*hasVertexShaderEffects = true; |
} |
} |
+ |
+ if (count > 0 && (*stages[0]->getEffect())->getWillUseInputColor()) { |
+ *willUseInputColor = true; |
+ } |
} |
bool GrGLProgram::bindOutputsAttribsAndLinkProgram(const GrGLShaderBuilder& builder, |
@@ -791,15 +669,6 @@ void GrGLProgram::setData(GrDrawState::BlendOptFlags blendOpts, |
this->setCoverage(drawState, coverage, sharedState); |
this->setMatrixAndRenderTargetHeight(drawState); |
- // Setup the SkXfermode::Mode-based colorfilter uniform if necessary |
- if (fUniformHandles.fColorFilterUni.isValid() && |
- fColorFilterColor != drawState.getColorFilterColor()) { |
- GrGLfloat c[4]; |
- GrColorToRGBAFloat(drawState.getColorFilterColor(), c); |
- fUniformManager.set4fv(fUniformHandles.fColorFilterUni, 0, 1, c); |
- fColorFilterColor = drawState.getColorFilterColor(); |
- } |
- |
if (NULL != dstCopy) { |
if (fUniformHandles.fDstCopyTopLeftUni.isValid()) { |
fUniformManager.set2f(fUniformHandles.fDstCopyTopLeftUni, |
@@ -822,17 +691,13 @@ void GrGLProgram::setData(GrDrawState::BlendOptFlags blendOpts, |
} |
for (int e = 0; e < fColorEffects.count(); ++e) { |
- // We may have omitted the GrGLEffect because of the color filter logic in genProgram. |
- // This can be removed when the color filter is an effect. |
- if (NULL != fColorEffects[e].fGLEffect) { |
- this->setEffectData(*colorStages[e], fColorEffects[e]); |
- } |
+ SkASSERT(NULL != fColorEffects[e].fGLEffect); |
+ this->setEffectData(*colorStages[e], fColorEffects[e]); |
} |
for (int e = 0; e < fCoverageEffects.count(); ++e) { |
- if (NULL != fCoverageEffects[e].fGLEffect) { |
- this->setEffectData(*coverageStages[e], fCoverageEffects[e]); |
- } |
+ SkASSERT(NULL != fCoverageEffects[e].fGLEffect); |
+ this->setEffectData(*coverageStages[e], fCoverageEffects[e]); |
} |
} |
@@ -855,7 +720,7 @@ void GrGLProgram::setColor(const GrDrawState& drawState, |
} |
break; |
case GrGLProgramDesc::kUniform_ColorInput: |
- if (fColor != color) { |
+ if (fColor != color && fUniformHandles.fColorUni.isValid()) { |
// OpenGL ES doesn't support unsigned byte varieties of glUniform |
GrGLfloat c[4]; |
GrColorToRGBAFloat(color, c); |