2011-10-31 14:33:35 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2011 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2014-06-19 19:32:29 +00:00
|
|
|
#include "Benchmark.h"
|
2011-10-31 14:33:35 +00:00
|
|
|
#include "SkAAClip.h"
|
2014-06-19 19:32:29 +00:00
|
|
|
#include "SkCanvas.h"
|
2011-10-31 14:33:35 +00:00
|
|
|
#include "SkPath.h"
|
2014-06-19 19:32:29 +00:00
|
|
|
#include "SkRandom.h"
|
2011-10-31 14:33:35 +00:00
|
|
|
#include "SkRegion.h"
|
|
|
|
#include "SkString.h"
|
2012-05-07 18:07:36 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// This bench tests out AA/BW clipping via canvas' clipPath and clipRect calls
|
2014-06-19 19:32:29 +00:00
|
|
|
class AAClipBench : public Benchmark {
|
2012-05-07 18:07:36 +00:00
|
|
|
SkString fName;
|
|
|
|
SkPath fClipPath;
|
|
|
|
SkRect fClipRect;
|
|
|
|
SkRect fDrawRect;
|
|
|
|
bool fDoPath;
|
|
|
|
bool fDoAA;
|
|
|
|
|
|
|
|
public:
|
2013-09-13 19:52:27 +00:00
|
|
|
AAClipBench(bool doPath, bool doAA)
|
|
|
|
: fDoPath(doPath)
|
2012-05-09 15:48:31 +00:00
|
|
|
, fDoAA(doAA) {
|
2012-05-07 18:07:36 +00:00
|
|
|
|
|
|
|
fName.printf("aaclip_%s_%s",
|
|
|
|
doPath ? "path" : "rect",
|
|
|
|
doAA ? "AA" : "BW");
|
|
|
|
|
2013-11-25 19:44:07 +00:00
|
|
|
fClipRect.set(10.5f, 10.5f,
|
|
|
|
50.5f, 50.5f);
|
2012-05-07 18:07:36 +00:00
|
|
|
fClipPath.addRoundRect(fClipRect, SkIntToScalar(10), SkIntToScalar(10));
|
|
|
|
fDrawRect.set(SkIntToScalar(0), SkIntToScalar(0),
|
|
|
|
SkIntToScalar(100), SkIntToScalar(100));
|
|
|
|
|
|
|
|
SkASSERT(fClipPath.isConvex());
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual const char* onGetName() { return fName.c_str(); }
|
2013-12-03 18:17:16 +00:00
|
|
|
virtual void onDraw(const int loops, SkCanvas* canvas) {
|
2012-05-07 18:07:36 +00:00
|
|
|
|
|
|
|
SkPaint paint;
|
|
|
|
this->setupPaint(&paint);
|
|
|
|
|
2013-12-03 18:17:16 +00:00
|
|
|
for (int i = 0; i < loops; ++i) {
|
2012-05-07 18:07:36 +00:00
|
|
|
// jostle the clip regions each time to prevent caching
|
|
|
|
fClipRect.offset((i % 2) == 0 ? SkIntToScalar(10) : SkIntToScalar(-10), 0);
|
|
|
|
fClipPath.reset();
|
2012-08-23 18:09:54 +00:00
|
|
|
fClipPath.addRoundRect(fClipRect,
|
2012-05-07 18:07:36 +00:00
|
|
|
SkIntToScalar(5), SkIntToScalar(5));
|
|
|
|
SkASSERT(fClipPath.isConvex());
|
|
|
|
|
|
|
|
canvas->save();
|
|
|
|
#if 1
|
|
|
|
if (fDoPath) {
|
|
|
|
canvas->clipPath(fClipPath, SkRegion::kReplace_Op, fDoAA);
|
|
|
|
} else {
|
|
|
|
canvas->clipRect(fClipRect, SkRegion::kReplace_Op, fDoAA);
|
|
|
|
}
|
|
|
|
|
|
|
|
canvas->drawRect(fDrawRect, paint);
|
|
|
|
#else
|
|
|
|
// this path tests out directly draw the clip primitive
|
|
|
|
// use it to comparing just drawing the clip vs. drawing using
|
|
|
|
// the clip
|
|
|
|
if (fDoPath) {
|
|
|
|
canvas->drawPath(fClipPath, paint);
|
|
|
|
} else {
|
|
|
|
canvas->drawRect(fClipRect, paint);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
canvas->restore();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private:
|
2014-06-19 19:32:29 +00:00
|
|
|
typedef Benchmark INHERITED;
|
2012-05-07 18:07:36 +00:00
|
|
|
};
|
|
|
|
|
2012-05-09 15:48:31 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// This bench tests out nested clip stacks. It is intended to simulate
|
|
|
|
// how WebKit nests clips.
|
2014-06-19 19:32:29 +00:00
|
|
|
class NestedAAClipBench : public Benchmark {
|
2012-05-09 15:48:31 +00:00
|
|
|
SkString fName;
|
|
|
|
bool fDoAA;
|
|
|
|
SkRect fDrawRect;
|
2013-09-09 20:09:12 +00:00
|
|
|
SkRandom fRandom;
|
2012-05-09 15:48:31 +00:00
|
|
|
|
2012-05-09 16:27:10 +00:00
|
|
|
static const int kNestingDepth = 3;
|
2012-05-09 15:48:31 +00:00
|
|
|
static const int kImageSize = 400;
|
|
|
|
|
|
|
|
SkPoint fSizes[kNestingDepth+1];
|
|
|
|
|
|
|
|
public:
|
2013-09-13 19:52:27 +00:00
|
|
|
NestedAAClipBench(bool doAA) : fDoAA(doAA) {
|
2012-05-09 15:48:31 +00:00
|
|
|
fName.printf("nested_aaclip_%s", doAA ? "AA" : "BW");
|
|
|
|
|
2012-08-23 18:09:54 +00:00
|
|
|
fDrawRect = SkRect::MakeLTRB(0, 0,
|
|
|
|
SkIntToScalar(kImageSize),
|
2012-05-09 15:48:31 +00:00
|
|
|
SkIntToScalar(kImageSize));
|
|
|
|
|
|
|
|
fSizes[0].set(SkIntToScalar(kImageSize), SkIntToScalar(kImageSize));
|
|
|
|
|
|
|
|
for (int i = 1; i < kNestingDepth+1; ++i) {
|
|
|
|
fSizes[i].set(fSizes[i-1].fX/2, fSizes[i-1].fY/2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual const char* onGetName() { return fName.c_str(); }
|
|
|
|
|
|
|
|
|
2012-08-23 18:09:54 +00:00
|
|
|
void recurse(SkCanvas* canvas,
|
2012-05-09 15:48:31 +00:00
|
|
|
int depth,
|
|
|
|
const SkPoint& offset) {
|
|
|
|
|
|
|
|
canvas->save();
|
|
|
|
|
2012-08-23 18:09:54 +00:00
|
|
|
SkRect temp = SkRect::MakeLTRB(0, 0,
|
2012-05-09 15:48:31 +00:00
|
|
|
fSizes[depth].fX, fSizes[depth].fY);
|
|
|
|
temp.offset(offset);
|
|
|
|
|
|
|
|
SkPath path;
|
|
|
|
path.addRoundRect(temp, SkIntToScalar(3), SkIntToScalar(3));
|
|
|
|
SkASSERT(path.isConvex());
|
|
|
|
|
2012-08-23 18:09:54 +00:00
|
|
|
canvas->clipPath(path,
|
|
|
|
0 == depth ? SkRegion::kReplace_Op :
|
2012-05-09 15:48:31 +00:00
|
|
|
SkRegion::kIntersect_Op,
|
|
|
|
fDoAA);
|
|
|
|
|
|
|
|
if (kNestingDepth == depth) {
|
|
|
|
// we only draw the draw rect at the lowest nesting level
|
|
|
|
SkPaint paint;
|
|
|
|
paint.setColor(0xff000000 | fRandom.nextU());
|
|
|
|
canvas->drawRect(fDrawRect, paint);
|
|
|
|
} else {
|
|
|
|
SkPoint childOffset = offset;
|
|
|
|
this->recurse(canvas, depth+1, childOffset);
|
|
|
|
|
|
|
|
childOffset += fSizes[depth+1];
|
|
|
|
this->recurse(canvas, depth+1, childOffset);
|
|
|
|
|
|
|
|
childOffset.fX = offset.fX + fSizes[depth+1].fX;
|
|
|
|
childOffset.fY = offset.fY;
|
|
|
|
this->recurse(canvas, depth+1, childOffset);
|
|
|
|
|
|
|
|
childOffset.fX = offset.fX;
|
|
|
|
childOffset.fY = offset.fY + fSizes[depth+1].fY;
|
|
|
|
this->recurse(canvas, depth+1, childOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
canvas->restore();
|
|
|
|
}
|
|
|
|
|
2013-12-03 18:17:16 +00:00
|
|
|
virtual void onDraw(const int loops, SkCanvas* canvas) {
|
2012-05-09 15:48:31 +00:00
|
|
|
|
2013-12-03 18:17:16 +00:00
|
|
|
for (int i = 0; i < loops; ++i) {
|
2012-05-09 15:48:31 +00:00
|
|
|
SkPoint offset = SkPoint::Make(0, 0);
|
|
|
|
this->recurse(canvas, 0, offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2014-06-19 19:32:29 +00:00
|
|
|
typedef Benchmark INHERITED;
|
2012-05-09 15:48:31 +00:00
|
|
|
};
|
|
|
|
|
2012-05-07 18:07:36 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2014-06-19 19:32:29 +00:00
|
|
|
class AAClipBuilderBench : public Benchmark {
|
2011-10-31 14:33:35 +00:00
|
|
|
SkString fName;
|
|
|
|
SkPath fPath;
|
|
|
|
SkRect fRect;
|
|
|
|
SkRegion fRegion;
|
|
|
|
bool fDoPath;
|
|
|
|
bool fDoAA;
|
|
|
|
|
|
|
|
public:
|
2013-09-13 19:52:27 +00:00
|
|
|
AAClipBuilderBench(bool doPath, bool doAA) {
|
2011-10-31 14:33:35 +00:00
|
|
|
fDoPath = doPath;
|
|
|
|
fDoAA = doAA;
|
|
|
|
|
|
|
|
fName.printf("aaclip_build_%s_%s", doPath ? "path" : "rect",
|
|
|
|
doAA ? "AA" : "BW");
|
|
|
|
|
|
|
|
fRegion.setRect(0, 0, 640, 480);
|
|
|
|
fRect.set(fRegion.getBounds());
|
|
|
|
fRect.inset(SK_Scalar1/4, SK_Scalar1/4);
|
|
|
|
fPath.addRoundRect(fRect, SkIntToScalar(20), SkIntToScalar(20));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual const char* onGetName() { return fName.c_str(); }
|
2013-12-03 18:17:16 +00:00
|
|
|
virtual void onDraw(const int loops, SkCanvas*) {
|
2011-10-31 14:33:35 +00:00
|
|
|
SkPaint paint;
|
|
|
|
this->setupPaint(&paint);
|
|
|
|
|
2013-12-03 18:17:16 +00:00
|
|
|
for (int i = 0; i < loops; ++i) {
|
2011-10-31 14:33:35 +00:00
|
|
|
SkAAClip clip;
|
|
|
|
if (fDoPath) {
|
|
|
|
clip.setPath(fPath, &fRegion, fDoAA);
|
|
|
|
} else {
|
|
|
|
clip.setRect(fRect, fDoAA);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private:
|
2014-06-19 19:32:29 +00:00
|
|
|
typedef Benchmark INHERITED;
|
2011-10-31 14:33:35 +00:00
|
|
|
};
|
|
|
|
|
2012-05-07 18:07:36 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2014-06-19 19:32:29 +00:00
|
|
|
class AAClipRegionBench : public Benchmark {
|
2011-11-28 19:54:56 +00:00
|
|
|
public:
|
2013-09-13 19:52:27 +00:00
|
|
|
AAClipRegionBench() {
|
2011-11-28 19:54:56 +00:00
|
|
|
SkPath path;
|
|
|
|
// test conversion of a complex clip to a aaclip
|
|
|
|
path.addCircle(0, 0, SkIntToScalar(200));
|
|
|
|
path.addCircle(0, 0, SkIntToScalar(180));
|
|
|
|
// evenodd means we've constructed basically a stroked circle
|
|
|
|
path.setFillType(SkPath::kEvenOdd_FillType);
|
|
|
|
|
|
|
|
SkIRect bounds;
|
|
|
|
path.getBounds().roundOut(&bounds);
|
|
|
|
fRegion.setPath(path, SkRegion(bounds));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual const char* onGetName() { return "aaclip_setregion"; }
|
2013-12-03 18:17:16 +00:00
|
|
|
virtual void onDraw(const int loops, SkCanvas*) {
|
|
|
|
for (int i = 0; i < loops; ++i) {
|
2011-11-28 19:54:56 +00:00
|
|
|
SkAAClip clip;
|
|
|
|
clip.setRegion(fRegion);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
SkRegion fRegion;
|
2014-06-19 19:32:29 +00:00
|
|
|
typedef Benchmark INHERITED;
|
2011-11-28 19:54:56 +00:00
|
|
|
};
|
|
|
|
|
2012-05-07 18:07:36 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2011-10-31 14:33:35 +00:00
|
|
|
|
2013-09-13 19:52:27 +00:00
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (false, false)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (false, true)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (true, false)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (true, true)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipRegionBench, ()); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBench, (false, false)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBench, (false, true)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBench, (true, false)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(AAClipBench, (true, true)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(NestedAAClipBench, (false)); )
|
|
|
|
DEF_BENCH( return SkNEW_ARGS(NestedAAClipBench, (true)); )
|