2011-07-28 18:26:00 +04: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.
|
|
|
|
*/
|
2011-04-13 21:44:24 +04:00
|
|
|
#include "SkBenchmark.h"
|
|
|
|
#include "SkBitmap.h"
|
|
|
|
#include "SkCanvas.h"
|
|
|
|
#include "SkColorPriv.h"
|
|
|
|
#include "SkGradientShader.h"
|
|
|
|
#include "SkPaint.h"
|
|
|
|
#include "SkShader.h"
|
|
|
|
#include "SkString.h"
|
|
|
|
#include "SkUnitMapper.h"
|
|
|
|
|
|
|
|
struct GradData {
|
|
|
|
int fCount;
|
|
|
|
const SkColor* fColors;
|
|
|
|
const SkScalar* fPos;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const SkColor gColors[] = {
|
|
|
|
SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
|
|
|
|
};
|
|
|
|
static const SkScalar gPos0[] = { 0, SK_Scalar1 };
|
|
|
|
static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
|
|
|
|
static const SkScalar gPos2[] = {
|
|
|
|
0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
|
|
|
|
};
|
|
|
|
|
|
|
|
static const GradData gGradData[] = {
|
|
|
|
{ 2, gColors, NULL },
|
|
|
|
{ 2, gColors, gPos0 },
|
|
|
|
{ 2, gColors, gPos1 },
|
|
|
|
{ 5, gColors, NULL },
|
|
|
|
{ 5, gColors, gPos2 }
|
|
|
|
};
|
|
|
|
|
2011-09-26 19:03:55 +04:00
|
|
|
/// Ignores scale
|
2011-04-13 21:44:24 +04:00
|
|
|
static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
|
2011-09-26 19:03:55 +04:00
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper,
|
|
|
|
float scale) {
|
2011-04-13 21:44:24 +04:00
|
|
|
return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
|
|
|
|
data.fCount, tm, mapper);
|
|
|
|
}
|
|
|
|
|
|
|
|
static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
|
2011-09-26 19:03:55 +04:00
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper,
|
|
|
|
float scale) {
|
2011-04-13 21:44:24 +04:00
|
|
|
SkPoint center;
|
|
|
|
center.set(SkScalarAve(pts[0].fX, pts[1].fX),
|
|
|
|
SkScalarAve(pts[0].fY, pts[1].fY));
|
2011-09-26 19:03:55 +04:00
|
|
|
return SkGradientShader::CreateRadial(center, center.fX * scale,
|
|
|
|
data.fColors,
|
2011-04-13 21:44:24 +04:00
|
|
|
data.fPos, data.fCount, tm, mapper);
|
|
|
|
}
|
|
|
|
|
2011-09-26 19:03:55 +04:00
|
|
|
/// Ignores scale
|
2011-04-13 21:44:24 +04:00
|
|
|
static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
|
2011-09-26 19:03:55 +04:00
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper,
|
|
|
|
float scale) {
|
2011-04-13 21:44:24 +04:00
|
|
|
SkPoint center;
|
|
|
|
center.set(SkScalarAve(pts[0].fX, pts[1].fX),
|
|
|
|
SkScalarAve(pts[0].fY, pts[1].fY));
|
|
|
|
return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
|
|
|
|
data.fPos, data.fCount, mapper);
|
|
|
|
}
|
|
|
|
|
2011-09-26 19:03:55 +04:00
|
|
|
/// Ignores scale
|
2011-04-13 21:44:24 +04:00
|
|
|
static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
|
2011-09-26 19:03:55 +04:00
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper,
|
|
|
|
float scale) {
|
2011-04-13 21:44:24 +04:00
|
|
|
SkPoint center0, center1;
|
|
|
|
center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
|
|
|
|
SkScalarAve(pts[0].fY, pts[1].fY));
|
|
|
|
center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
|
|
|
|
SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
|
|
|
|
return SkGradientShader::CreateTwoPointRadial(
|
2012-06-07 18:18:34 +04:00
|
|
|
center1, (pts[1].fX - pts[0].fX) / 7,
|
|
|
|
center0, (pts[1].fX - pts[0].fX) / 2,
|
|
|
|
data.fColors, data.fPos, data.fCount, tm, mapper);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Ignores scale
|
|
|
|
static SkShader* MakeConical(const SkPoint pts[2], const GradData& data,
|
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper,
|
|
|
|
float scale) {
|
|
|
|
SkPoint center0, center1;
|
|
|
|
center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
|
|
|
|
SkScalarAve(pts[0].fY, pts[1].fY));
|
|
|
|
center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
|
|
|
|
SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
|
|
|
|
return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
|
|
|
|
center0, (pts[1].fX - pts[0].fX) / 2,
|
|
|
|
data.fColors, data.fPos, data.fCount, tm, mapper);
|
2011-04-13 21:44:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
|
2011-09-26 19:03:55 +04:00
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper,
|
|
|
|
float scale);
|
2011-04-13 21:44:24 +04:00
|
|
|
|
|
|
|
static const struct {
|
|
|
|
GradMaker fMaker;
|
|
|
|
const char* fName;
|
|
|
|
int fRepeat;
|
|
|
|
} gGrads[] = {
|
|
|
|
{ MakeLinear, "linear", 15 },
|
2011-04-13 22:32:19 +04:00
|
|
|
{ MakeRadial, "radial1", 10 },
|
2011-04-13 21:44:24 +04:00
|
|
|
{ MakeSweep, "sweep", 1 },
|
|
|
|
{ Make2Radial, "radial2", 5 },
|
2012-06-07 18:18:34 +04:00
|
|
|
{ MakeConical, "conical", 5 },
|
2011-04-13 21:44:24 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
enum GradType { // these must match the order in gGrads
|
|
|
|
kLinear_GradType,
|
|
|
|
kRadial_GradType,
|
|
|
|
kSweep_GradType,
|
2012-06-07 18:18:34 +04:00
|
|
|
kRadial2_GradType,
|
|
|
|
kConical_GradType
|
2011-04-13 21:44:24 +04:00
|
|
|
};
|
|
|
|
|
2011-09-26 19:03:55 +04:00
|
|
|
enum GeomType {
|
|
|
|
kRect_GeomType,
|
|
|
|
kOval_GeomType
|
|
|
|
};
|
|
|
|
|
2011-06-16 01:17:37 +04:00
|
|
|
static const char* tilemodename(SkShader::TileMode tm) {
|
|
|
|
switch (tm) {
|
|
|
|
case SkShader::kClamp_TileMode:
|
|
|
|
return "clamp";
|
|
|
|
case SkShader::kRepeat_TileMode:
|
|
|
|
return "repeat";
|
|
|
|
case SkShader::kMirror_TileMode:
|
|
|
|
return "mirror";
|
|
|
|
default:
|
|
|
|
SkASSERT(!"unknown tilemode");
|
|
|
|
return "error";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-26 19:03:55 +04:00
|
|
|
static const char* geomtypename(GeomType gt) {
|
|
|
|
switch (gt) {
|
|
|
|
case kRect_GeomType:
|
|
|
|
return "rectangle";
|
|
|
|
case kOval_GeomType:
|
|
|
|
return "oval";
|
|
|
|
default:
|
|
|
|
SkASSERT(!"unknown geometry type");
|
|
|
|
return "error";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-13 21:44:24 +04:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
class GradientBench : public SkBenchmark {
|
|
|
|
SkString fName;
|
|
|
|
SkShader* fShader;
|
|
|
|
int fCount;
|
|
|
|
enum {
|
|
|
|
W = 400,
|
|
|
|
H = 400,
|
|
|
|
N = 1
|
|
|
|
};
|
|
|
|
public:
|
2011-09-26 19:03:55 +04:00
|
|
|
GradientBench(void* param, GradType gradType,
|
|
|
|
SkShader::TileMode tm = SkShader::kClamp_TileMode,
|
|
|
|
GeomType geomType = kRect_GeomType,
|
|
|
|
float scale = 1.0f)
|
|
|
|
: INHERITED(param) {
|
|
|
|
fName.printf("gradient_%s_%s", gGrads[gradType].fName,
|
|
|
|
tilemodename(tm));
|
|
|
|
if (geomType != kRect_GeomType) {
|
|
|
|
fName.append("_");
|
|
|
|
fName.append(geomtypename(geomType));
|
|
|
|
}
|
2011-04-13 21:44:24 +04:00
|
|
|
|
|
|
|
const SkPoint pts[2] = {
|
|
|
|
{ 0, 0 },
|
|
|
|
{ SkIntToScalar(W), SkIntToScalar(H) }
|
|
|
|
};
|
2012-08-23 22:09:54 +04:00
|
|
|
|
2011-10-28 19:34:49 +04:00
|
|
|
fCount = SkBENCHLOOP(N * gGrads[gradType].fRepeat);
|
2011-09-26 19:03:55 +04:00
|
|
|
fShader = gGrads[gradType].fMaker(pts, gGradData[0], tm, NULL, scale);
|
|
|
|
fGeomType = geomType;
|
2011-04-13 21:44:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~GradientBench() {
|
|
|
|
fShader->unref();
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual const char* onGetName() {
|
|
|
|
return fName.c_str();
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
|
|
|
SkPaint paint;
|
|
|
|
this->setupPaint(&paint);
|
|
|
|
|
|
|
|
paint.setShader(fShader);
|
|
|
|
|
|
|
|
SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
|
|
|
|
for (int i = 0; i < fCount; i++) {
|
2011-09-26 19:03:55 +04:00
|
|
|
switch (fGeomType) {
|
|
|
|
case kRect_GeomType:
|
|
|
|
canvas->drawRect(r, paint);
|
|
|
|
break;
|
|
|
|
case kOval_GeomType:
|
|
|
|
canvas->drawOval(r, paint);
|
|
|
|
break;
|
|
|
|
}
|
2011-04-13 21:44:24 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
typedef SkBenchmark INHERITED;
|
2011-09-26 19:03:55 +04:00
|
|
|
|
|
|
|
GeomType fGeomType;
|
2011-04-13 21:44:24 +04:00
|
|
|
};
|
|
|
|
|
2011-06-16 17:14:19 +04:00
|
|
|
class Gradient2Bench : public SkBenchmark {
|
|
|
|
public:
|
|
|
|
Gradient2Bench(void* param) : INHERITED(param) {}
|
2012-08-23 22:09:54 +04:00
|
|
|
|
2011-06-16 17:14:19 +04:00
|
|
|
protected:
|
|
|
|
virtual const char* onGetName() {
|
|
|
|
return "gradient_create";
|
|
|
|
}
|
2012-08-23 22:09:54 +04:00
|
|
|
|
2011-06-16 17:14:19 +04:00
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
|
|
|
SkPaint paint;
|
|
|
|
this->setupPaint(&paint);
|
2012-08-23 22:09:54 +04:00
|
|
|
|
2011-06-16 17:14:19 +04:00
|
|
|
const SkRect r = { 0, 0, SkIntToScalar(4), SkIntToScalar(4) };
|
2011-06-24 23:17:37 +04:00
|
|
|
const SkPoint pts[] = {
|
|
|
|
{ 0, 0 },
|
|
|
|
{ SkIntToScalar(100), SkIntToScalar(100) },
|
|
|
|
};
|
2011-06-16 17:14:19 +04:00
|
|
|
|
2011-10-28 19:34:49 +04:00
|
|
|
for (int i = 0; i < SkBENCHLOOP(1000); i++) {
|
2011-06-17 21:56:23 +04:00
|
|
|
const int a = i % 256;
|
2011-09-26 19:03:55 +04:00
|
|
|
SkColor colors[] = {
|
|
|
|
SK_ColorBLACK,
|
|
|
|
SkColorSetARGB(a, a, a, a),
|
|
|
|
SK_ColorWHITE };
|
2011-06-16 17:14:19 +04:00
|
|
|
SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL,
|
|
|
|
SK_ARRAY_COUNT(colors),
|
|
|
|
SkShader::kClamp_TileMode);
|
|
|
|
paint.setShader(s)->unref();
|
|
|
|
canvas->drawRect(r, paint);
|
|
|
|
}
|
|
|
|
}
|
2012-08-23 22:09:54 +04:00
|
|
|
|
2011-06-16 17:14:19 +04:00
|
|
|
private:
|
|
|
|
typedef SkBenchmark INHERITED;
|
|
|
|
};
|
|
|
|
|
2011-04-13 21:44:24 +04:00
|
|
|
static SkBenchmark* Fact0(void* p) { return new GradientBench(p, kLinear_GradType); }
|
2011-06-16 17:14:19 +04:00
|
|
|
static SkBenchmark* Fact01(void* p) { return new GradientBench(p, kLinear_GradType, SkShader::kMirror_TileMode); }
|
2011-09-26 19:03:55 +04:00
|
|
|
|
|
|
|
// Draw a radial gradient of radius 1/2 on a rectangle; half the lines should
|
|
|
|
// be completely pinned, the other half should pe partially pinned
|
|
|
|
static SkBenchmark* Fact1(void* p) { return new GradientBench(p, kRadial_GradType, SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); }
|
|
|
|
|
|
|
|
// Draw a radial gradient on a circle of equal size; all the lines should
|
|
|
|
// hit the unpinned fast path (so long as GradientBench.W == H)
|
|
|
|
static SkBenchmark* Fact1o(void* p) { return new GradientBench(p, kRadial_GradType, SkShader::kClamp_TileMode, kOval_GeomType); }
|
|
|
|
|
2011-06-16 01:17:37 +04:00
|
|
|
static SkBenchmark* Fact11(void* p) { return new GradientBench(p, kRadial_GradType, SkShader::kMirror_TileMode); }
|
2011-04-13 21:44:24 +04:00
|
|
|
static SkBenchmark* Fact2(void* p) { return new GradientBench(p, kSweep_GradType); }
|
|
|
|
static SkBenchmark* Fact3(void* p) { return new GradientBench(p, kRadial2_GradType); }
|
2011-06-16 17:14:19 +04:00
|
|
|
static SkBenchmark* Fact31(void* p) { return new GradientBench(p, kRadial2_GradType, SkShader::kMirror_TileMode); }
|
2012-06-07 18:18:34 +04:00
|
|
|
static SkBenchmark* Fact5(void* p) { return new GradientBench(p, kConical_GradType); }
|
2011-06-16 17:14:19 +04:00
|
|
|
|
|
|
|
static SkBenchmark* Fact4(void* p) { return new Gradient2Bench(p); }
|
2011-04-13 21:44:24 +04:00
|
|
|
|
|
|
|
static BenchRegistry gReg0(Fact0);
|
2011-06-16 17:14:19 +04:00
|
|
|
static BenchRegistry gReg01(Fact01);
|
2011-04-13 21:44:24 +04:00
|
|
|
static BenchRegistry gReg1(Fact1);
|
2011-09-26 19:03:55 +04:00
|
|
|
static BenchRegistry gReg1o(Fact1o);
|
2011-06-16 01:17:37 +04:00
|
|
|
static BenchRegistry gReg11(Fact11);
|
2011-04-13 21:44:24 +04:00
|
|
|
static BenchRegistry gReg2(Fact2);
|
|
|
|
static BenchRegistry gReg3(Fact3);
|
2011-06-16 17:14:19 +04:00
|
|
|
static BenchRegistry gReg31(Fact31);
|
2012-06-07 18:18:34 +04:00
|
|
|
static BenchRegistry gReg5(Fact5);
|
2011-06-16 17:14:19 +04:00
|
|
|
|
|
|
|
static BenchRegistry gReg4(Fact4);
|
2011-04-13 21:44:24 +04:00
|
|
|
|