diff options
-rw-r--r-- | bench/AlternatingColorPatternBench.cpp | 200 | ||||
-rw-r--r-- | expectations/gm/ignored-tests.txt | 12 | ||||
-rw-r--r-- | gyp/bench.gypi | 1 | ||||
-rw-r--r-- | src/gpu/GrDrawState.cpp | 9 | ||||
-rw-r--r-- | src/gpu/GrDrawState.h | 6 | ||||
-rw-r--r-- | src/gpu/gl/GrGLProgram.cpp | 11 | ||||
-rw-r--r-- | src/gpu/gl/GrGLProgramDesc.cpp | 18 | ||||
-rw-r--r-- | src/gpu/gl/GrGLProgramDesc.h | 1 | ||||
-rw-r--r-- | src/gpu/gl/GrGLShaderBuilder.cpp | 6 | ||||
-rw-r--r-- | src/gpu/gl/GrGpuGL_program.cpp | 4 | ||||
-rw-r--r-- | tests/GLProgramsTest.cpp | 5 |
11 files changed, 242 insertions, 31 deletions
diff --git a/bench/AlternatingColorPatternBench.cpp b/bench/AlternatingColorPatternBench.cpp new file mode 100644 index 0000000000..b497979a89 --- /dev/null +++ b/bench/AlternatingColorPatternBench.cpp @@ -0,0 +1,200 @@ +/* + * Copyright 2014 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "Benchmark.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPaint.h" +#include "SkString.h" + +enum ColorPattern { + kWhite_ColorPattern, + kBlue_ColorPattern, + kOpaqueBitmap_ColorPattern, + kAlphaBitmap_ColorPattern, +}; + +static const struct ColorPatternData{ + SkColor fColor; + bool fIsBitmap; + const char* fName; +} gColorPatterns[] = { + // Keep this in same order as ColorPattern enum + { SK_ColorWHITE, false, "white" }, // kWhite_ColorPattern + { SK_ColorBLUE, false, "blue" }, // kBlue_ColorPattern + { SK_ColorWHITE, true, "obaqueBitMap" }, // kOpaqueBitmap_ColorPattern + { 0x10000000, true, "alphaBitmap" }, // kAlphaBitmap_ColorPattern +}; + +enum DrawType { + kRect_DrawType, + kPath_DrawType, +}; + +static void makebm(SkBitmap* bm, int w, int h) { + bm->allocN32Pixels(w, h); + bm->eraseColor(SK_ColorTRANSPARENT); + + SkCanvas canvas(*bm); + SkScalar s = SkIntToScalar(SkMin32(w, h)); + static const SkPoint kPts0[] = { { 0, 0 }, { s, s } }; + static const SkPoint kPts1[] = { { s/2, 0 }, { s/2, s } }; + static const SkScalar kPos[] = { 0, SK_Scalar1/2, SK_Scalar1 }; + static const SkColor kColors0[] = {0x80F00080, 0xF0F08000, 0x800080F0 }; + static const SkColor kColors1[] = {0xF08000F0, 0x8080F000, 0xF000F080 }; + + + SkPaint paint; + + paint.setShader(SkGradientShader::CreateLinear(kPts0, kColors0, kPos, + SK_ARRAY_COUNT(kColors0), SkShader::kClamp_TileMode))->unref(); + canvas.drawPaint(paint); + paint.setShader(SkGradientShader::CreateLinear(kPts1, kColors1, kPos, + SK_ARRAY_COUNT(kColors1), SkShader::kClamp_TileMode))->unref(); + canvas.drawPaint(paint); +} + +/** + * This bench draws a grid of either rects or filled paths, with two alternating color patterns. + * This color patterns are passed in as enums to the class. The options are: + * 1) solid white color + * 2) solid blue color + * 3) opaque bitmap + * 4) partial alpha bitmap + * The same color pattern can be set for both arguments to create a uniform pattern on all draws. + * + * The bench is used to test a few things. First it can test any optimizations made for a specific + * color pattern (for example drawing an opaque bitmap versus one with partial alpha). Also it can + * be used to test the cost of program switching and/or batching when alternating between different + * patterns when on the gpu. + */ +class AlternatingColorPatternBench : public Benchmark { +public: + enum { + NX = 5, + NY = 5, + NUM_DRAWS = NX * NY, + }; + SkShader* fBmShader; + + SkPath fPaths[NUM_DRAWS]; + SkRect fRects[NUM_DRAWS]; + SkColor fColors[NUM_DRAWS]; + SkShader* fShaders[NUM_DRAWS]; + + SkString fName; + ColorPatternData fPattern1; + ColorPatternData fPattern2; + DrawType fDrawType; + SkBitmap fBmp; + + + AlternatingColorPatternBench(ColorPattern pattern1, ColorPattern pattern2, DrawType drawType) + : fBmShader(NULL) { + fPattern1 = gColorPatterns[pattern1]; + fPattern2 = gColorPatterns[pattern2]; + fName.printf("colorPattern_%s_%s_%s", + fPattern1.fName, fPattern2.fName, + kRect_DrawType == drawType ? "rect" : "path"); + fDrawType = drawType; + } + + virtual ~AlternatingColorPatternBench() { + SkSafeUnref(fBmShader); + } + +protected: + virtual const char* onGetName() SK_OVERRIDE { + return fName.c_str(); + } + + virtual void onPreDraw() { + int w = 40; + int h = 40; + makebm(&fBmp, w, h); + fBmShader = SkShader::CreateBitmapShader(fBmp, + SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode); + int offset = 2; + int count = 0; + for (int j = 0; j < NY; ++j) { + for (int i = 0; i < NX; ++i) { + int x = (w + offset) * i; + int y = (h * offset) * j; + if (kRect_DrawType == fDrawType) { + fRects[count].set(SkIntToScalar(x), SkIntToScalar(y), + SkIntToScalar(x + w), SkIntToScalar(y + h)); + } else { + fPaths[count].moveTo(SkIntToScalar(x), SkIntToScalar(y)); + fPaths[count].rLineTo(SkIntToScalar(w), 0); + fPaths[count].rLineTo(0, SkIntToScalar(h)); + fPaths[count].rLineTo(SkIntToScalar(-w + 1), 0); + } + if (0 == count % 2) { + fColors[count] = fPattern1.fColor; + fShaders[count] = fPattern1.fIsBitmap ? fBmShader : NULL; + } else { + fColors[count] = fPattern2.fColor; + fShaders[count] = fPattern2.fIsBitmap ? fBmShader : NULL; + } + ++count; + } + } + } + + virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { + SkPaint paint; + paint.setAntiAlias(false); + paint.setFilterLevel(SkPaint::kLow_FilterLevel); + + for (int i = 0; i < loops; ++i) { + for (int j = 0; j < NUM_DRAWS; ++j) { + paint.setColor(fColors[j]); + paint.setShader(fShaders[j]); + if (kRect_DrawType == fDrawType) { + canvas->drawRect(fRects[j], paint); + } else { + canvas->drawPath(fPaths[j], paint); + } + } + } + } + +private: + typedef Benchmark INHERITED; +}; + +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kWhite_ColorPattern, kWhite_ColorPattern, + kPath_DrawType)); ) +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kBlue_ColorPattern, kBlue_ColorPattern, + kPath_DrawType)); ) +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kWhite_ColorPattern, kBlue_ColorPattern, + kPath_DrawType)); ) + +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern, + kPath_DrawType)); ) +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern, + kPath_DrawType)); ) +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern, + kPath_DrawType)); ) + +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern, + kRect_DrawType)); ) +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern, + kRect_DrawType)); ) +DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench, + (kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern, + kRect_DrawType)); ) + diff --git a/expectations/gm/ignored-tests.txt b/expectations/gm/ignored-tests.txt index c97a0b9de2..d8c0476c09 100644 --- a/expectations/gm/ignored-tests.txt +++ b/expectations/gm/ignored-tests.txt @@ -33,6 +33,18 @@ ## epoger will rebaseline by 25 Dec 2013 #gradtext +# egdaniel: removing a gpu shader optimization causes some single pixel changes in gm +# cl: https://codereview.chromium.org/375823005/#ps210001 +coloremoji +complexclip2 +complexclip2_path_bw +complexclip2_rrect_bw +gradients_view_perspective +imagefiltersbase +inverse_paths +xfermodes3 +verylargebitmap + # reed: bitmapfilters changed (labels) with hide_config CL, just need rebaselines bitmapfilters diff --git a/gyp/bench.gypi b/gyp/bench.gypi index c8d20616e5..b8406e2efa 100644 --- a/gyp/bench.gypi +++ b/gyp/bench.gypi @@ -23,6 +23,7 @@ '../bench/Benchmark.h', '../bench/AAClipBench.cpp', + '../bench/AlternatingColorPatternBench.cpp', '../bench/BitmapBench.cpp', '../bench/BitmapRectBench.cpp', '../bench/BitmapScaleBench.cpp', diff --git a/src/gpu/GrDrawState.cpp b/src/gpu/GrDrawState.cpp index 14ba6fad5d..02c7920f5d 100644 --- a/src/gpu/GrDrawState.cpp +++ b/src/gpu/GrDrawState.cpp @@ -409,6 +409,15 @@ GrDrawState::BlendOptFlags GrDrawState::calcBlendOpts(bool forceCoverage, return kNone_BlendOpt; } +bool GrDrawState::canIgnoreColorAttribute() const { + if (fBlendOptFlags & kInvalid_BlendOptFlag) { + this->getBlendOpts(); + } + return SkToBool(fBlendOptFlags & (GrDrawState::kEmitTransBlack_BlendOptFlag | + GrDrawState::kEmitCoverage_BlendOptFlag)); +} + + //////////////////////////////////////////////////////////////////////////////// void GrDrawState::AutoViewMatrixRestore::restore() { diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h index cef21af880..c1dd9dcd36 100644 --- a/src/gpu/GrDrawState.h +++ b/src/gpu/GrDrawState.h @@ -551,6 +551,12 @@ public: } /** + * We don't use suplied vertex color attributes if our blend mode is EmitCoverage or + * EmitTransBlack + */ + bool canIgnoreColorAttribute() const; + + /** * Determines what optimizations can be applied based on the blend. The coefficients may have * to be tweaked in order for the optimization to work. srcCoeff and dstCoeff are optional * params that receive the tweaked coefficients. Normally the function looks at the current diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp index 435d0cdb02..5bc7d0b277 100644 --- a/src/gpu/gl/GrGLProgram.cpp +++ b/src/gpu/gl/GrGLProgram.cpp @@ -154,7 +154,7 @@ void GrGLProgram::setColor(const GrDrawState& drawState, GrColor color, SharedGLState* sharedState) { const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader(); - if (!drawState.hasColorVertexAttribute()) { + if (!drawState.hasColorVertexAttribute() || drawState.canIgnoreColorAttribute()) { switch (header.fColorInput) { case GrGLProgramDesc::kAttribute_ColorInput: SkASSERT(-1 != header.fColorAttributeIndex); @@ -178,12 +178,8 @@ void GrGLProgram::setColor(const GrDrawState& drawState, } sharedState->fConstAttribColorIndex = -1; break; - case GrGLProgramDesc::kSolidWhite_ColorInput: - case GrGLProgramDesc::kTransBlack_ColorInput: - sharedState->fConstAttribColorIndex = -1; - break; default: - SkFAIL("Unknown color type."); + SkFAIL("Unexpected color type."); } } else { sharedState->fConstAttribColorIndex = -1; @@ -218,11 +214,10 @@ void GrGLProgram::setCoverage(const GrDrawState& drawState, sharedState->fConstAttribCoverageIndex = -1; break; case GrGLProgramDesc::kSolidWhite_ColorInput: - case GrGLProgramDesc::kTransBlack_ColorInput: sharedState->fConstAttribCoverageIndex = -1; break; default: - SkFAIL("Unknown coverage type."); + SkFAIL("Unexpected coverage type."); } } else { sharedState->fConstAttribCoverageIndex = -1; diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp index 27a1fab1e0..e1a319104d 100644 --- a/src/gpu/gl/GrGLProgramDesc.cpp +++ b/src/gpu/gl/GrGLProgramDesc.cpp @@ -66,6 +66,7 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState, bool skipColor = SkToBool(blendOpts & (GrDrawState::kEmitTransBlack_BlendOptFlag | GrDrawState::kEmitCoverage_BlendOptFlag)); + int firstEffectiveColorStage = 0; bool inputColorIsUsed = true; if (!skipColor) { @@ -99,11 +100,6 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState, bool requiresLocalCoordAttrib = !(skipCoverage && skipColor) && drawState.hasLocalCoordAttribute(); - bool colorIsTransBlack = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag); - bool colorIsSolidWhite = (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) || - (!requiresColorAttrib && 0xffffffff == drawState.getColor()) || - (!inputColorIsUsed); - bool readsDst = false; bool readFragPosition = false; // We use vertexshader-less shader programs only when drawing paths. @@ -192,11 +188,7 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState, #endif bool defaultToUniformInputs = GR_GL_NO_CONSTANT_ATTRIBUTES || gpu->caps()->pathRenderingSupport(); - if (colorIsTransBlack) { - header->fColorInput = kTransBlack_ColorInput; - } else if (colorIsSolidWhite) { - header->fColorInput = kSolidWhite_ColorInput; - } else if (defaultToUniformInputs && !requiresColorAttrib) { + if (defaultToUniformInputs && !requiresColorAttrib && inputColorIsUsed) { header->fColorInput = kUniform_ColorInput; } else { header->fColorInput = kAttribute_ColorInput; @@ -205,11 +197,9 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState, bool covIsSolidWhite = !requiresCoverageAttrib && 0xffffffff == drawState.getCoverageColor(); - if (skipCoverage) { - header->fCoverageInput = kTransBlack_ColorInput; - } else if (covIsSolidWhite || !inputCoverageIsUsed) { + if ((covIsSolidWhite || !inputCoverageIsUsed) && !skipCoverage) { header->fCoverageInput = kSolidWhite_ColorInput; - } else if (defaultToUniformInputs && !requiresCoverageAttrib) { + } else if (defaultToUniformInputs && !requiresCoverageAttrib && inputCoverageIsUsed) { header->fCoverageInput = kUniform_ColorInput; } else { header->fCoverageInput = kAttribute_ColorInput; diff --git a/src/gpu/gl/GrGLProgramDesc.h b/src/gpu/gl/GrGLProgramDesc.h index a8d27ab269..cccdee9ce2 100644 --- a/src/gpu/gl/GrGLProgramDesc.h +++ b/src/gpu/gl/GrGLProgramDesc.h @@ -100,7 +100,6 @@ private: // Specifies where the initial color comes from before the stages are applied. enum ColorInput { kSolidWhite_ColorInput, - kTransBlack_ColorInput, kAttribute_ColorInput, kUniform_ColorInput, diff --git a/src/gpu/gl/GrGLShaderBuilder.cpp b/src/gpu/gl/GrGLShaderBuilder.cpp index 7a57d8e32e..8d1e66be7c 100644 --- a/src/gpu/gl/GrGLShaderBuilder.cpp +++ b/src/gpu/gl/GrGLShaderBuilder.cpp @@ -164,10 +164,6 @@ bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[], this->addUniform(GrGLShaderBuilder::kFragment_Visibility, kVec4f_GrSLType, "Color", &name); inputColor = GrGLSLExpr4(name); - } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fColorInput) { - inputColor = GrGLSLExpr4(1); - } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fColorInput) { - inputColor = GrGLSLExpr4(0); } if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) { @@ -178,8 +174,6 @@ bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[], inputCoverage = GrGLSLExpr4(name); } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) { inputCoverage = GrGLSLExpr4(1); - } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fCoverageInput) { - inputCoverage = GrGLSLExpr4(0); } if (k110_GrGLSLGeneration != fGpu->glslGeneration()) { diff --git a/src/gpu/gl/GrGpuGL_program.cpp b/src/gpu/gl/GrGpuGL_program.cpp index 9e1b6f5c2b..45181c25a8 100644 --- a/src/gpu/gl/GrGpuGL_program.cpp +++ b/src/gpu/gl/GrGpuGL_program.cpp @@ -353,9 +353,12 @@ void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) { uint32_t usedAttribArraysMask = 0; const GrVertexAttrib* vertexAttrib = this->getDrawState().getVertexAttribs(); + bool canIgnoreColorAttrib = this->getDrawState().canIgnoreColorAttribute(); + for (int vertexAttribIndex = 0; vertexAttribIndex < vertexAttribCount; ++vertexAttribIndex, ++vertexAttrib) { + if (kColor_GrVertexAttribBinding != vertexAttrib->fBinding || !canIgnoreColorAttrib) { usedAttribArraysMask |= (1 << vertexAttribIndex); GrVertexAttribType attribType = vertexAttrib->fType; attribState->set(this, @@ -367,6 +370,7 @@ void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) { stride, reinterpret_cast<GrGLvoid*>( vertexOffsetInBytes + vertexAttrib->fOffset)); + } } attribState->disableUnusedArrays(this, usedAttribArraysMask); } diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp index 899b42fb4f..9da1ecc53c 100644 --- a/tests/GLProgramsTest.cpp +++ b/tests/GLProgramsTest.cpp @@ -73,8 +73,9 @@ bool GrGLProgramDesc::setRandom(SkRandom* random, // if the effects have used up all off the available attributes, // don't try to use color or coverage attributes as input do { - header->fColorInput = static_cast<GrGLProgramDesc::ColorInput>( - random->nextULessThan(kColorInputCnt)); + uint32_t colorRand = random->nextULessThan(2); + header->fColorInput = (0 == colorRand) ? GrGLProgramDesc::kAttribute_ColorInput : + GrGLProgramDesc::kUniform_ColorInput; } while (GrDrawState::kMaxVertexAttribCnt <= currAttribIndex && kAttribute_ColorInput == header->fColorInput); |