diff options
| -rw-r--r-- | bench/PatchBench.cpp | 30 | ||||
| -rw-r--r-- | bench/PatchGridBench.cpp | 259 | ||||
| -rw-r--r-- | gyp/bench.gypi | 1 | ||||
| -rw-r--r-- | src/utils/SkPatchGrid.cpp | 15 |
4 files changed, 283 insertions, 22 deletions
diff --git a/bench/PatchBench.cpp b/bench/PatchBench.cpp index 8ce80c4bc5..744141a879 100644 --- a/bench/PatchBench.cpp +++ b/bench/PatchBench.cpp @@ -5,16 +5,19 @@ * found in the LICENSE file. */ #include "Benchmark.h" -#include "SkBitmap.h" #include "SkCanvas.h" -#include "SkColorPriv.h" #include "SkGradientShader.h" #include "SkPaint.h" #include "SkPatchUtils.h" -#include "SkRandom.h" -#include "SkShader.h" #include "SkString.h" -#include "SkTArray.h" + +/** + * This bench measures the rendering time of the call SkCanvas::drawPatch with different types of + * input patches (regular case, with loops, a square, with a big difference between "parallel" + * sides). This bench also tests the different combination of optional parameters for the function + * (passing texture coordinates and colors, only textures coordinates, only colors or none). + * Finally, it applies a scale to test if the size affects the rendering time. + */ class PatchBench : public Benchmark { @@ -92,7 +95,7 @@ protected: vertexMode.set("texs"); break; case kBoth_VertexMode: - vertexMode.set("colors&texs"); + vertexMode.set("colors_texs"); break; default: break; @@ -104,12 +107,7 @@ protected: return fName.c_str(); } - virtual void preDraw() { - - } - - virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { - + virtual void onPreDraw() SK_OVERRIDE { this->setCubics(); this->setColors(); this->setTexCoords(); @@ -123,7 +121,9 @@ protected: fPaint.setShader(NULL); break; } + } + virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { canvas->scale(fScale.x(), fScale.y()); for (int i = 0; i < loops; i++) { switch (fVertexMode) { @@ -165,7 +165,7 @@ public: name->append("square"); } - virtual void setCubics() { + virtual void setCubics() SK_OVERRIDE { const SkPoint points[SkPatchUtils::kNumCtrlPts] = { //top points {100,100},{150,100},{250,100}, {300,100}, @@ -191,7 +191,7 @@ public: name->append("LOD_Diff"); } - virtual void setCubics() { + virtual void setCubics() SK_OVERRIDE { const SkPoint points[SkPatchUtils::kNumCtrlPts] = { //top points {100,175},{150,100},{250,100}, {300,0}, @@ -217,7 +217,7 @@ public: name->append("loop"); } - virtual void setCubics() { + virtual void setCubics() SK_OVERRIDE { const SkPoint points[SkPatchUtils::kNumCtrlPts] = { //top points {100,100},{300,200},{100,200}, {300,100}, diff --git a/bench/PatchGridBench.cpp b/bench/PatchGridBench.cpp new file mode 100644 index 0000000000..c250781893 --- /dev/null +++ b/bench/PatchGridBench.cpp @@ -0,0 +1,259 @@ +/* + * 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 "SkPatchGrid.h" +#include "SkString.h" + + /** + * This bench measures the rendering time of a gridof patches. + * This bench also tests the different combination of optional parameters for the function + * (passing texture coordinates and colors, only textures coordinates, only colors or none). + * Finally, it also has 3 possible sizes small, medium and big to test if the size of the patches + * in the grid affects time. + */ + +class PatchGridBench : public Benchmark { + +public: + + enum Size { + kSmall_Size, + kMedium_Size, + kBig_Size + }; + + enum VertexMode { + kNone_VertexMode, + kColors_VertexMode, + kTexCoords_VertexMode, + kBoth_VertexMode + }; + + PatchGridBench(Size size, VertexMode vertexMode) + : fVertexMode(vertexMode) + , fSize(size) { } + + void setScale(SkCanvas* canvas){ + switch (fSize) { + case kSmall_Size: + canvas->scale(0.1f, 0.1f); + break; + case kMedium_Size: + canvas->scale(1.0f, 1.0f); + break; + case kBig_Size: + canvas->scale(3.0f, 3.0f); + break; + } + } + + void setGrid() { + SkPoint vertices[4][5] = { + {{50,50}, {150,50}, {250,50},{350,50},{450,50}}, + {{50,150}, {120,120}, {250,150},{350,150},{450,150}}, + {{50,250}, {150,250}, {250,250},{350,250},{450,250}}, + {{100,300}, {150,350}, {250,350},{350,350},{450,350}} + }; + + SkColor cornerColors[4][5] = { + {SK_ColorBLUE, SK_ColorRED, SK_ColorBLUE, SK_ColorRED, SK_ColorBLUE}, + {SK_ColorRED, SK_ColorBLUE, SK_ColorRED, SK_ColorBLUE, SK_ColorRED}, + {SK_ColorBLUE, SK_ColorRED, SK_ColorBLUE, SK_ColorRED, SK_ColorBLUE}, + {SK_ColorRED, SK_ColorBLUE, SK_ColorRED, SK_ColorBLUE, SK_ColorRED}, + }; + + SkPoint texCoords[4][5] = { + {{0.0f,0.0f}, {1.0f,0.0f}, {2.0f,0.0f}, {3.0f,0.0f}, {4.0f,0.0f}}, + {{0.0f,1.0f}, {1.0f,1.0f}, {2.0f,1.0f}, {3.0f,1.0f}, {4.0f,1.0f}}, + {{0.0f,2.0f}, {1.0f,2.0f}, {2.0f,2.0f}, {3.0f,2.0f}, {4.0f,2.0f}}, + {{0.0f,3.0f}, {1.0f,3.0f}, {2.0f,3.0f}, {3.0f,3.0f}, {4.0f,3.0f}}, + }; + + SkPoint hrzCtrl[4][8] = { + {{75,30},{125,45},{175,70},{225,20},{275,50},{325,50},{375,5},{425,90}}, + {{75,150},{125,150},{175,150},{225,150},{275,150},{325,150},{375,150},{425,150}}, + {{75,250},{125,250},{175,250},{225,250},{275,200},{325,150},{375,250},{425,250}}, + {{75,350},{125,350},{175,350},{225,350},{275,350},{325,350},{375,350},{425,350}} + }; + + SkPoint vrtCtrl[6][5] = { + {{50,75},{150,75},{250,75},{350,75},{450,75}}, + {{50,125},{150,125},{250,125},{350,125},{450,125}}, + {{50,175},{150,175},{220,225},{350,175},{470,225}}, + {{50,225},{150,225},{220,175},{350,225},{470,155}}, + {{50,275},{150,275},{250,275},{350,275},{400,305}}, + {{50,325},{150,325},{250,325},{350,325},{450,325}} + }; + + static const int kRows = 3; + static const int kCols = 4; + + fGrid.reset(kRows, kCols, SkPatchGrid::kColors_VertexType, NULL); + for (int i = 0; i < kRows; i++) { + for (int j = 0; j < kCols; j++) { + SkPoint points[12]; + + //set corners + points[SkPatchUtils::kTopP0_CubicCtrlPts] = vertices[i][j]; + points[SkPatchUtils::kTopP3_CubicCtrlPts] = vertices[i][j + 1]; + points[SkPatchUtils::kBottomP0_CubicCtrlPts] = vertices[i + 1][j]; + points[SkPatchUtils::kBottomP3_CubicCtrlPts] = vertices[i + 1][j + 1]; + + points[SkPatchUtils::kTopP1_CubicCtrlPts] = hrzCtrl[i][j * 2]; + points[SkPatchUtils::kTopP2_CubicCtrlPts] = hrzCtrl[i][j * 2 + 1]; + points[SkPatchUtils::kBottomP1_CubicCtrlPts] = hrzCtrl[i + 1][j * 2]; + points[SkPatchUtils::kBottomP2_CubicCtrlPts] = hrzCtrl[i + 1][j * 2 + 1]; + + points[SkPatchUtils::kLeftP1_CubicCtrlPts] = vrtCtrl[i * 2][j]; + points[SkPatchUtils::kLeftP2_CubicCtrlPts] = vrtCtrl[i * 2 + 1][j]; + points[SkPatchUtils::kRightP1_CubicCtrlPts] = vrtCtrl[i * 2][j + 1]; + points[SkPatchUtils::kRightP2_CubicCtrlPts] = vrtCtrl[i * 2 + 1][j + 1]; + + SkColor colors[4]; + colors[0] = cornerColors[i][j]; + colors[1] = cornerColors[i][j + 1]; + colors[3] = cornerColors[i + 1][j]; + colors[2] = cornerColors[i + 1][j + 1]; + + SkPoint texs[4]; + texs[0] = texCoords[i][j]; + texs[1] = texCoords[i][j + 1]; + texs[3] = texCoords[i + 1][j]; + texs[2] = texCoords[i + 1][j + 1]; + + switch (fVertexMode) { + case kNone_VertexMode: + fGrid.setPatch(j, i, points, NULL, NULL); + break; + case kColors_VertexMode: + fGrid.setPatch(j, i, points, colors, NULL); + break; + case kTexCoords_VertexMode: + fGrid.setPatch(j, i, points, NULL, texs); + break; + case kBoth_VertexMode: + fGrid.setPatch(j, i, points, colors, texs); + break; + default: + break; + } + } + } + } + + // override this method to change the shader + SkShader* createShader() { + const SkColor colors[] = { + SK_ColorRED, SK_ColorCYAN, SK_ColorGREEN, SK_ColorWHITE, + SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorYELLOW, + }; + const SkPoint pts[] = { { 200.f / 4.f, 0.f }, { 3.f * 200.f / 4, 200.f } }; + + return SkGradientShader::CreateLinear(pts, colors, NULL, + SK_ARRAY_COUNT(colors), + SkShader::kMirror_TileMode); + } + +protected: + virtual const char* onGetName() SK_OVERRIDE { + SkString vertexMode; + switch (fVertexMode) { + case kNone_VertexMode: + vertexMode.set("meshlines"); + break; + case kColors_VertexMode: + vertexMode.set("colors"); + break; + case kTexCoords_VertexMode: + vertexMode.set("texs"); + break; + case kBoth_VertexMode: + vertexMode.set("colors_texs"); + break; + default: + break; + } + + SkString size; + switch (fSize) { + case kSmall_Size: + size.set("small"); + break; + case kMedium_Size: + size.set("medium"); + break; + case kBig_Size: + size.set("big"); + break; + default: + break; + } + fName.printf("patch_grid_%s_%s", vertexMode.c_str(), size.c_str()); + return fName.c_str(); + } + + virtual void onPreDraw() SK_OVERRIDE { + this->setGrid(); + switch (fVertexMode) { + case kTexCoords_VertexMode: + case kBoth_VertexMode: + fPaint.setShader(createShader())->unref(); + break; + default: + fPaint.setShader(NULL); + break; + } + this->setupPaint(&fPaint); + } + + virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { + this->setScale(canvas); + for (int i = 0; i < loops; i++) { + fGrid.draw(canvas, fPaint); + } + } + + SkPaint fPaint; + SkString fName; + SkPatchGrid fGrid; + VertexMode fVertexMode; + Size fSize; + + typedef Benchmark INHERITED; +}; + + +/////////////////////////////////////////////////////////////////////////////// + +DEF_BENCH( return new PatchGridBench(PatchGridBench::kSmall_Size, + PatchGridBench::kNone_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kSmall_Size, + PatchGridBench::kColors_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kSmall_Size, + PatchGridBench::kTexCoords_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kSmall_Size, + PatchGridBench::kBoth_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kMedium_Size, + PatchGridBench::kNone_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kMedium_Size, + PatchGridBench::kColors_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kMedium_Size, + PatchGridBench::kTexCoords_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kMedium_Size, + PatchGridBench::kBoth_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size, + PatchGridBench::kNone_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size, + PatchGridBench::kColors_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size, + PatchGridBench::kTexCoords_VertexMode); ) +DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size, + PatchGridBench::kBoth_VertexMode); ) diff --git a/gyp/bench.gypi b/gyp/bench.gypi index 30f0aa661c..92e0574f2b 100644 --- a/gyp/bench.gypi +++ b/gyp/bench.gypi @@ -70,6 +70,7 @@ '../bench/MorphologyBench.cpp', '../bench/MutexBench.cpp', '../bench/PatchBench.cpp', + '../bench/PatchGridBench.cpp', '../bench/PathBench.cpp', '../bench/PathIterBench.cpp', '../bench/PathUtilsBench.cpp', diff --git a/src/utils/SkPatchGrid.cpp b/src/utils/SkPatchGrid.cpp index b1fea57403..a0809f3594 100644 --- a/src/utils/SkPatchGrid.cpp +++ b/src/utils/SkPatchGrid.cpp @@ -174,13 +174,14 @@ void SkPatchGrid::draw(SkCanvas* canvas, SkPaint& paint) { SkColor colors[4]; this->getPatch(x, y, cubics, colors, texCoords); SkPatchUtils::VertexData data; - SkPatchUtils::getVertexData(&data, cubics, - fModeFlags & kColors_VertexType ? colors : NULL, - fModeFlags & kTexs_VertexType ? texCoords : NULL, - maxCols[x], maxRows[y]); - canvas->drawVertices(SkCanvas::kTriangles_VertexMode, data.fVertexCount, - data.fPoints, data.fTexCoords, data.fColors, fXferMode, - data.fIndices, data.fIndexCount, paint); + if (SkPatchUtils::getVertexData(&data, cubics, + fModeFlags & kColors_VertexType ? colors : NULL, + fModeFlags & kTexs_VertexType ? texCoords : NULL, + maxCols[x], maxRows[y])) { + canvas->drawVertices(SkCanvas::kTriangles_VertexMode, data.fVertexCount, + data.fPoints, data.fTexCoords, data.fColors, fXferMode, + data.fIndices, data.fIndexCount, paint); + } } } SkDELETE_ARRAY(maxCols); |