bool GrPaint::getOpaqueAndKnownColor(GrColor* solidColor, uint32_t* solidColorKnownComponents) const { // TODO: Share this implementation with GrDrawState GrProcessor::InvariantOutput inout; inout.fColor = GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage); inout.fValidFlags = kRGBA_GrColorComponentFlags; inout.fIsSingleComponent = false; int count = fCoverageStages.count(); for (int i = 0; i < count; ++i) { fCoverageStages[i].getProcessor()->computeInvariantOutput(&inout); } if (!inout.isSolidWhite()) { return false; } inout.fColor = fColor; inout.fValidFlags = kRGBA_GrColorComponentFlags; inout.fIsSingleComponent = false; count = fColorStages.count(); for (int i = 0; i < count; ++i) { fColorStages[i].getProcessor()->computeInvariantOutput(&inout); } SkASSERT((NULL == solidColor) == (NULL == solidColorKnownComponents)); GrBlendCoeff srcCoeff = fSrcBlendCoeff; GrBlendCoeff dstCoeff = fDstBlendCoeff; GrSimplifyBlend(&srcCoeff, &dstCoeff, inout.fColor, inout.fValidFlags, 0, 0, 0); bool opaque = kZero_GrBlendCoeff == dstCoeff && !GrBlendCoeffRefsDst(srcCoeff); if (solidColor) { if (opaque) { switch (srcCoeff) { case kZero_GrBlendCoeff: *solidColor = 0; *solidColorKnownComponents = kRGBA_GrColorComponentFlags; break; case kOne_GrBlendCoeff: *solidColor = inout.fColor; *solidColorKnownComponents = inout.fValidFlags; break; // The src coeff should never refer to the src and if it refers to dst then opaque // should have been false. case kSC_GrBlendCoeff: case kISC_GrBlendCoeff: case kDC_GrBlendCoeff: case kIDC_GrBlendCoeff: case kSA_GrBlendCoeff: case kISA_GrBlendCoeff: case kDA_GrBlendCoeff: case kIDA_GrBlendCoeff: default: SkFAIL("srcCoeff should not refer to src or dst."); break; // TODO: update this once GrPaint actually has a const color. case kConstC_GrBlendCoeff: case kIConstC_GrBlendCoeff: case kConstA_GrBlendCoeff: case kIConstA_GrBlendCoeff: *solidColorKnownComponents = 0; break; } } else { solidColorKnownComponents = 0; } } return opaque; }
bool GrPaint::getOpaqueAndKnownColor(GrColor* solidColor, uint32_t* solidColorKnownComponents) const { // TODO: Share this implementation with GrDrawState GrColor coverage = GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage); uint32_t coverageComps = kRGBA_GrColorComponentFlags; int count = fCoverageStages.count(); for (int i = 0; i < count; ++i) { (*fCoverageStages[i].getEffect())->getConstantColorComponents(&coverage, &coverageComps); } if (kRGBA_GrColorComponentFlags != coverageComps || 0xffffffff != coverage) { return false; } GrColor color = fColor; uint32_t colorComps = kRGBA_GrColorComponentFlags; count = fColorStages.count(); for (int i = 0; i < count; ++i) { (*fColorStages[i].getEffect())->getConstantColorComponents(&color, &colorComps); } SkASSERT((NULL == solidColor) == (NULL == solidColorKnownComponents)); GrBlendCoeff srcCoeff = fSrcBlendCoeff; GrBlendCoeff dstCoeff = fDstBlendCoeff; GrSimplifyBlend(&srcCoeff, &dstCoeff, color, colorComps, 0, 0, 0); bool opaque = kZero_GrBlendCoeff == dstCoeff && !GrBlendCoeffRefsDst(srcCoeff); if (NULL != solidColor) { if (opaque) { switch (srcCoeff) { case kZero_GrBlendCoeff: *solidColor = 0; *solidColorKnownComponents = kRGBA_GrColorComponentFlags; break; case kOne_GrBlendCoeff: *solidColor = color; *solidColorKnownComponents = colorComps; break; // The src coeff should never refer to the src and if it refers to dst then opaque // should have been false. case kSC_GrBlendCoeff: case kISC_GrBlendCoeff: case kDC_GrBlendCoeff: case kIDC_GrBlendCoeff: case kSA_GrBlendCoeff: case kISA_GrBlendCoeff: case kDA_GrBlendCoeff: case kIDA_GrBlendCoeff: default: SkFAIL("srcCoeff should not refer to src or dst."); break; // TODO: update this once GrPaint actually has a const color. case kConstC_GrBlendCoeff: case kIConstC_GrBlendCoeff: case kConstA_GrBlendCoeff: case kIConstA_GrBlendCoeff: *solidColorKnownComponents = 0; break; } } else { solidColorKnownComponents = 0; } } return opaque; }
void GrPorterDuffXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI, GrXPFactory::InvariantOutput* output) const { if (!coveragePOI.isSolidWhite()) { output->fWillBlendWithDst = true; output->fBlendedColorFlags = 0; return; } GrBlendCoeff srcCoeff = fSrcCoeff; GrBlendCoeff dstCoeff = fDstCoeff; // TODO: figure out to merge this simplify with other current optimization code paths and // eventually remove from GrBlend GrSimplifyBlend(&srcCoeff, &dstCoeff, colorPOI.color(), colorPOI.validFlags(), 0, 0, 0); if (GrBlendCoeffRefsDst(srcCoeff)) { output->fWillBlendWithDst = true; output->fBlendedColorFlags = 0; return; } if (kZero_GrBlendCoeff != dstCoeff) { bool srcAIsOne = colorPOI.isOpaque(); if (kISA_GrBlendCoeff != dstCoeff || !srcAIsOne) { output->fWillBlendWithDst = true; } output->fBlendedColorFlags = 0; return; } switch (srcCoeff) { case kZero_GrBlendCoeff: output->fBlendedColor = 0; output->fBlendedColorFlags = kRGBA_GrColorComponentFlags; break; case kOne_GrBlendCoeff: output->fBlendedColor = colorPOI.color(); output->fBlendedColorFlags = colorPOI.validFlags(); break; // The src coeff should never refer to the src and if it refers to dst then opaque // should have been false. case kSC_GrBlendCoeff: case kISC_GrBlendCoeff: case kDC_GrBlendCoeff: case kIDC_GrBlendCoeff: case kSA_GrBlendCoeff: case kISA_GrBlendCoeff: case kDA_GrBlendCoeff: case kIDA_GrBlendCoeff: default: SkFAIL("srcCoeff should not refer to src or dst."); break; // TODO: update this once GrPaint actually has a const color. case kConstC_GrBlendCoeff: case kIConstC_GrBlendCoeff: case kConstA_GrBlendCoeff: case kIConstA_GrBlendCoeff: output->fBlendedColorFlags = 0; break; } output->fWillBlendWithDst = false; }