From b09bdd6bac5bfff12b0b2a95681761e783a4b432 Mon Sep 17 00:00:00 2001 From: egdaniel Date: Tue, 29 Jul 2014 08:52:23 -0700 Subject: Revert of Remove gpu support for willUseHWAALines. (https://codereview.chromium.org/423943003/) Reason for revert: Breaking windows 7 compare gm's Original issue's description: > Remove gpu support for willUseHWAALines. > > By removing willUseHWAALines, we also no long reference the blend opt flag kDisableBlend so it has been removed > > BUG=skia: > > Committed: https://skia.googlesource.com/skia/+/e6dfba868c19b00562f8c733b9bf37dd4ec9e68c R=bsalomon@google.com TBR=bsalomon@google.com NOTREECHECKS=true NOTRY=true BUG=skia: Author: egdaniel@google.com Review URL: https://codereview.chromium.org/430493003 --- src/gpu/gl/GrGpuGL.cpp | 107 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 74 insertions(+), 33 deletions(-) (limited to 'src/gpu/gl/GrGpuGL.cpp') diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp index 988b64e679..a0e08e5a00 100644 --- a/src/gpu/gl/GrGpuGL.cpp +++ b/src/gpu/gl/GrGpuGL.cpp @@ -280,8 +280,8 @@ void GrGpuGL::onResetContext(uint32_t resetBits) { GL_CALL(LineWidth(1)); } - if (resetBits & kMSAAEnable_GrGLBackendState) { - fMSAAEnabled = kUnknown_TriState; + if (resetBits & kAA_GrGLBackendState) { + fHWAAState.invalidate(); } fHWActiveTextureUnitIdx = -1; // invalid @@ -2164,20 +2164,45 @@ void GrGpuGL::flushAAState(DrawType type) { const GrRenderTarget* rt = this->getDrawState().getRenderTarget(); if (kGL_GrGLStandard == this->glStandard()) { - if (RT_HAS_MSAA) { + // ES doesn't support toggling GL_MULTISAMPLE and doesn't have + // smooth lines. + // we prefer smooth lines over multisampled lines + bool smoothLines = false; + + if (kDrawLines_DrawType == type) { + smoothLines = this->willUseHWAALines(); + if (smoothLines) { + if (kYes_TriState != fHWAAState.fSmoothLineEnabled) { + GL_CALL(Enable(GR_GL_LINE_SMOOTH)); + fHWAAState.fSmoothLineEnabled = kYes_TriState; + // must disable msaa to use line smoothing + if (RT_HAS_MSAA && + kNo_TriState != fHWAAState.fMSAAEnabled) { + GL_CALL(Disable(GR_GL_MULTISAMPLE)); + fHWAAState.fMSAAEnabled = kNo_TriState; + } + } + } else { + if (kNo_TriState != fHWAAState.fSmoothLineEnabled) { + GL_CALL(Disable(GR_GL_LINE_SMOOTH)); + fHWAAState.fSmoothLineEnabled = kNo_TriState; + } + } + } + if (!smoothLines && RT_HAS_MSAA) { // FIXME: GL_NV_pr doesn't seem to like MSAA disabled. The paths // convex hulls of each segment appear to get filled. bool enableMSAA = kStencilPath_DrawType == type || this->getDrawState().isHWAntialiasState(); if (enableMSAA) { - if (kYes_TriState != fMSAAEnabled) { + if (kYes_TriState != fHWAAState.fMSAAEnabled) { GL_CALL(Enable(GR_GL_MULTISAMPLE)); - fMSAAEnabled = kYes_TriState; + fHWAAState.fMSAAEnabled = kYes_TriState; } } else { - if (kNo_TriState != fMSAAEnabled) { + if (kNo_TriState != fHWAAState.fMSAAEnabled) { GL_CALL(Disable(GR_GL_MULTISAMPLE)); - fMSAAEnabled = kNo_TriState; + fHWAAState.fMSAAEnabled = kNo_TriState; } } } @@ -2203,36 +2228,52 @@ void GrGpuGL::flushPathStencilSettings(SkPath::FillType fill) { void GrGpuGL::flushBlend(bool isLines, GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) { - // any optimization to disable blending should have already been applied and - // tweaked the coeffs to (1, 0). - bool blendOff = kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff; - if (blendOff) { - if (kNo_TriState != fHWBlendState.fEnabled) { - GL_CALL(Disable(GR_GL_BLEND)); - fHWBlendState.fEnabled = kNo_TriState; - } - } else { + if (isLines && this->willUseHWAALines()) { if (kYes_TriState != fHWBlendState.fEnabled) { GL_CALL(Enable(GR_GL_BLEND)); fHWBlendState.fEnabled = kYes_TriState; } - if (fHWBlendState.fSrcCoeff != srcCoeff || - fHWBlendState.fDstCoeff != dstCoeff) { - GL_CALL(BlendFunc(gXfermodeCoeff2Blend[srcCoeff], - gXfermodeCoeff2Blend[dstCoeff])); - fHWBlendState.fSrcCoeff = srcCoeff; - fHWBlendState.fDstCoeff = dstCoeff; - } - GrColor blendConst = this->getDrawState().getBlendConstant(); - if ((BlendCoeffReferencesConstant(srcCoeff) || - BlendCoeffReferencesConstant(dstCoeff)) && - (!fHWBlendState.fConstColorValid || - fHWBlendState.fConstColor != blendConst)) { - GrGLfloat c[4]; - GrColorToRGBAFloat(blendConst, c); - GL_CALL(BlendColor(c[0], c[1], c[2], c[3])); - fHWBlendState.fConstColor = blendConst; - fHWBlendState.fConstColorValid = true; + if (kSA_GrBlendCoeff != fHWBlendState.fSrcCoeff || + kISA_GrBlendCoeff != fHWBlendState.fDstCoeff) { + GL_CALL(BlendFunc(gXfermodeCoeff2Blend[kSA_GrBlendCoeff], + gXfermodeCoeff2Blend[kISA_GrBlendCoeff])); + fHWBlendState.fSrcCoeff = kSA_GrBlendCoeff; + fHWBlendState.fDstCoeff = kISA_GrBlendCoeff; + } + } else { + // any optimization to disable blending should + // have already been applied and tweaked the coeffs + // to (1, 0). + bool blendOff = kOne_GrBlendCoeff == srcCoeff && + kZero_GrBlendCoeff == dstCoeff; + if (blendOff) { + if (kNo_TriState != fHWBlendState.fEnabled) { + GL_CALL(Disable(GR_GL_BLEND)); + fHWBlendState.fEnabled = kNo_TriState; + } + } else { + if (kYes_TriState != fHWBlendState.fEnabled) { + GL_CALL(Enable(GR_GL_BLEND)); + fHWBlendState.fEnabled = kYes_TriState; + } + if (fHWBlendState.fSrcCoeff != srcCoeff || + fHWBlendState.fDstCoeff != dstCoeff) { + GL_CALL(BlendFunc(gXfermodeCoeff2Blend[srcCoeff], + gXfermodeCoeff2Blend[dstCoeff])); + fHWBlendState.fSrcCoeff = srcCoeff; + fHWBlendState.fDstCoeff = dstCoeff; + } + GrColor blendConst = this->getDrawState().getBlendConstant(); + if ((BlendCoeffReferencesConstant(srcCoeff) || + BlendCoeffReferencesConstant(dstCoeff)) && + (!fHWBlendState.fConstColorValid || + fHWBlendState.fConstColor != blendConst)) { + GrGLfloat c[4]; + GrColorToRGBAFloat(blendConst, c); + GL_CALL(BlendColor(c[0], c[1], c[2], c[3])); + fHWBlendState.fConstColor = blendConst; + fHWBlendState.fConstColorValid = true; + } } } } -- cgit v1.2.3