e50f7361b4
and endcap style as the stroked curved path. Review URL: http://codereview.appspot.com/5529069/ git-svn-id: http://skia.googlecode.com/svn/trunk@3028 2bbb7eff-a529-9590-31e7-b0007b416f81
264 lines
7.7 KiB
C++
264 lines
7.7 KiB
C++
|
|
/*
|
|
* Copyright 2011 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
#include "SkBenchmark.h"
|
|
#include "SkBitmap.h"
|
|
#include "SkCanvas.h"
|
|
#include "SkColorPriv.h"
|
|
#include "SkPaint.h"
|
|
#include "SkRandom.h"
|
|
#include "SkShader.h"
|
|
#include "SkString.h"
|
|
|
|
enum Flags {
|
|
kStroke_Flag = 1 << 0,
|
|
kBig_Flag = 1 << 1
|
|
};
|
|
|
|
#define FLAGS00 Flags(0)
|
|
#define FLAGS01 Flags(kStroke_Flag)
|
|
#define FLAGS10 Flags(kBig_Flag)
|
|
#define FLAGS11 Flags(kStroke_Flag | kBig_Flag)
|
|
|
|
class PathBench : public SkBenchmark {
|
|
SkPaint fPaint;
|
|
SkString fName;
|
|
Flags fFlags;
|
|
enum { N = SkBENCHLOOP(1000) };
|
|
public:
|
|
PathBench(void* param, Flags flags) : INHERITED(param), fFlags(flags) {
|
|
fPaint.setStyle(flags & kStroke_Flag ? SkPaint::kStroke_Style :
|
|
SkPaint::kFill_Style);
|
|
fPaint.setStrokeWidth(SkIntToScalar(5));
|
|
fPaint.setStrokeJoin(SkPaint::kBevel_Join);
|
|
}
|
|
|
|
virtual void appendName(SkString*) = 0;
|
|
virtual void makePath(SkPath*) = 0;
|
|
virtual int complexity() { return 0; }
|
|
|
|
protected:
|
|
virtual const char* onGetName() {
|
|
fName.printf("path_%s_%s_",
|
|
fFlags & kStroke_Flag ? "stroke" : "fill",
|
|
fFlags & kBig_Flag ? "big" : "small");
|
|
this->appendName(&fName);
|
|
return fName.c_str();
|
|
}
|
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
|
SkPaint paint(fPaint);
|
|
this->setupPaint(&paint);
|
|
|
|
SkPath path;
|
|
this->makePath(&path);
|
|
if (fFlags & kBig_Flag) {
|
|
SkMatrix m;
|
|
m.setScale(SkIntToScalar(10), SkIntToScalar(10));
|
|
path.transform(m);
|
|
}
|
|
|
|
int count = N;
|
|
if (fFlags & kBig_Flag) {
|
|
count >>= 2;
|
|
}
|
|
count >>= (3 * complexity());
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
canvas->drawPath(path, paint);
|
|
}
|
|
}
|
|
|
|
private:
|
|
typedef SkBenchmark INHERITED;
|
|
};
|
|
|
|
class TrianglePathBench : public PathBench {
|
|
public:
|
|
TrianglePathBench(void* param, Flags flags) : INHERITED(param, flags) {}
|
|
|
|
virtual void appendName(SkString* name) {
|
|
name->append("triangle");
|
|
}
|
|
virtual void makePath(SkPath* path) {
|
|
static const int gCoord[] = {
|
|
10, 10, 15, 5, 20, 20
|
|
};
|
|
path->moveTo(SkIntToScalar(gCoord[0]), SkIntToScalar(gCoord[1]));
|
|
path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3]));
|
|
path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5]));
|
|
path->close();
|
|
}
|
|
private:
|
|
typedef PathBench INHERITED;
|
|
};
|
|
|
|
class RectPathBench : public PathBench {
|
|
public:
|
|
RectPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
|
|
|
|
virtual void appendName(SkString* name) {
|
|
name->append("rect");
|
|
}
|
|
virtual void makePath(SkPath* path) {
|
|
SkRect r = { 10, 10, 20, 20 };
|
|
path->addRect(r);
|
|
}
|
|
private:
|
|
typedef PathBench INHERITED;
|
|
};
|
|
|
|
class OvalPathBench : public PathBench {
|
|
public:
|
|
OvalPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
|
|
|
|
virtual void appendName(SkString* name) {
|
|
name->append("oval");
|
|
}
|
|
virtual void makePath(SkPath* path) {
|
|
SkRect r = { 10, 10, 20, 20 };
|
|
path->addOval(r);
|
|
}
|
|
private:
|
|
typedef PathBench INHERITED;
|
|
};
|
|
|
|
class SawToothPathBench : public PathBench {
|
|
public:
|
|
SawToothPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
|
|
|
|
virtual void appendName(SkString* name) {
|
|
name->append("sawtooth");
|
|
}
|
|
virtual void makePath(SkPath* path) {
|
|
SkScalar x = SkIntToScalar(20);
|
|
SkScalar y = SkIntToScalar(20);
|
|
const SkScalar x0 = x;
|
|
const SkScalar dx = SK_Scalar1 * 5;
|
|
const SkScalar dy = SK_Scalar1 * 10;
|
|
|
|
path->moveTo(x, y);
|
|
for (int i = 0; i < 32; i++) {
|
|
x += dx;
|
|
path->lineTo(x, y - dy);
|
|
x += dx;
|
|
path->lineTo(x, y + dy);
|
|
}
|
|
path->lineTo(x, y + 2 * dy);
|
|
path->lineTo(x0, y + 2 * dy);
|
|
path->close();
|
|
}
|
|
virtual int complexity() { return 1; }
|
|
private:
|
|
typedef PathBench INHERITED;
|
|
};
|
|
|
|
class LongCurvedPathBench : public PathBench {
|
|
public:
|
|
LongCurvedPathBench(void * param, Flags flags)
|
|
: INHERITED(param, flags) {
|
|
}
|
|
|
|
virtual void appendName(SkString* name) {
|
|
name->append("long_curved");
|
|
}
|
|
virtual void makePath(SkPath* path) {
|
|
SkRandom rand (12);
|
|
int i;
|
|
for (i = 0; i < 100; i++) {
|
|
path->quadTo(SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
|
|
SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)),
|
|
SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
|
|
SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)));
|
|
}
|
|
path->close();
|
|
}
|
|
virtual int complexity() { return 2; }
|
|
private:
|
|
typedef PathBench INHERITED;
|
|
};
|
|
|
|
class LongLinePathBench : public PathBench {
|
|
public:
|
|
LongLinePathBench(void * param, Flags flags)
|
|
: INHERITED(param, flags) {
|
|
}
|
|
|
|
virtual void appendName(SkString* name) {
|
|
name->append("long_line");
|
|
}
|
|
virtual void makePath(SkPath* path) {
|
|
SkRandom rand;
|
|
path->moveTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
|
|
for (size_t i = 1; i < 100; i++) {
|
|
path->lineTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
|
|
}
|
|
}
|
|
virtual int complexity() { return 2; }
|
|
private:
|
|
typedef PathBench INHERITED;
|
|
};
|
|
|
|
|
|
static SkBenchmark* FactT00(void* p) { return new TrianglePathBench(p, FLAGS00); }
|
|
static SkBenchmark* FactT01(void* p) { return new TrianglePathBench(p, FLAGS01); }
|
|
static SkBenchmark* FactT10(void* p) { return new TrianglePathBench(p, FLAGS10); }
|
|
static SkBenchmark* FactT11(void* p) { return new TrianglePathBench(p, FLAGS11); }
|
|
|
|
static SkBenchmark* FactR00(void* p) { return new RectPathBench(p, FLAGS00); }
|
|
static SkBenchmark* FactR01(void* p) { return new RectPathBench(p, FLAGS01); }
|
|
static SkBenchmark* FactR10(void* p) { return new RectPathBench(p, FLAGS10); }
|
|
static SkBenchmark* FactR11(void* p) { return new RectPathBench(p, FLAGS11); }
|
|
|
|
static SkBenchmark* FactO00(void* p) { return new OvalPathBench(p, FLAGS00); }
|
|
static SkBenchmark* FactO01(void* p) { return new OvalPathBench(p, FLAGS01); }
|
|
static SkBenchmark* FactO10(void* p) { return new OvalPathBench(p, FLAGS10); }
|
|
static SkBenchmark* FactO11(void* p) { return new OvalPathBench(p, FLAGS11); }
|
|
|
|
static SkBenchmark* FactS00(void* p) { return new SawToothPathBench(p, FLAGS00); }
|
|
static SkBenchmark* FactS01(void* p) { return new SawToothPathBench(p, FLAGS01); }
|
|
|
|
static SkBenchmark* FactLC00(void* p) {
|
|
return new LongCurvedPathBench(p, FLAGS00);
|
|
}
|
|
static SkBenchmark* FactLC01(void* p) {
|
|
return new LongCurvedPathBench(p, FLAGS01);
|
|
}
|
|
|
|
static SkBenchmark* FactLL00(void* p) {
|
|
return new LongLinePathBench(p, FLAGS00);
|
|
}
|
|
|
|
static SkBenchmark* FactLL01(void* p) {
|
|
return new LongLinePathBench(p, FLAGS01);
|
|
}
|
|
|
|
static BenchRegistry gRegT00(FactT00);
|
|
static BenchRegistry gRegT01(FactT01);
|
|
static BenchRegistry gRegT10(FactT10);
|
|
static BenchRegistry gRegT11(FactT11);
|
|
|
|
static BenchRegistry gRegR00(FactR00);
|
|
static BenchRegistry gRegR01(FactR01);
|
|
static BenchRegistry gRegR10(FactR10);
|
|
static BenchRegistry gRegR11(FactR11);
|
|
|
|
static BenchRegistry gRegO00(FactO00);
|
|
static BenchRegistry gRegO01(FactO01);
|
|
static BenchRegistry gRegO10(FactO10);
|
|
static BenchRegistry gRegO11(FactO11);
|
|
|
|
static BenchRegistry gRegS00(FactS00);
|
|
static BenchRegistry gRegS01(FactS01);
|
|
|
|
static BenchRegistry gRegLC00(FactLC00);
|
|
static BenchRegistry gRegLC01(FactLC01);
|
|
|
|
static BenchRegistry gRegLL00(FactLL00);
|
|
static BenchRegistry gRegLL01(FactLL01);
|
|
|