2011-07-28 14:26:00 +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.
|
|
|
|
*/
|
2009-06-22 02:06:35 +00:00
|
|
|
#include "gm.h"
|
|
|
|
#include "SkGradientShader.h"
|
|
|
|
|
|
|
|
namespace skiagm {
|
|
|
|
|
|
|
|
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 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
|
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper) {
|
|
|
|
return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
|
|
|
|
data.fCount, tm, mapper);
|
|
|
|
}
|
2010-12-23 16:45:33 +00:00
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
|
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper) {
|
|
|
|
SkPoint center;
|
|
|
|
center.set(SkScalarAve(pts[0].fX, pts[1].fX),
|
|
|
|
SkScalarAve(pts[0].fY, pts[1].fY));
|
|
|
|
return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
|
|
|
|
data.fPos, data.fCount, tm, mapper);
|
|
|
|
}
|
|
|
|
|
|
|
|
static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
|
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper) {
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2010-12-23 16:45:33 +00:00
|
|
|
static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
|
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper) {
|
|
|
|
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(
|
|
|
|
center1, (pts[1].fX - pts[0].fX) / 7,
|
|
|
|
center0, (pts[1].fX - pts[0].fX) / 2,
|
|
|
|
data.fColors, data.fPos, data.fCount, tm, mapper);
|
|
|
|
}
|
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
|
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper) {
|
|
|
|
SkPoint center0, center1;
|
|
|
|
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
|
|
|
|
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
|
|
|
|
center0.set(pts[0].fX + radius0, pts[0].fY + radius0);
|
|
|
|
center1.set(pts[1].fX - radius1, pts[1].fY - radius1);
|
2012-08-23 18:14:13 +00:00
|
|
|
return SkGradientShader::CreateTwoPointConical(center1, radius1,
|
|
|
|
center0, radius0,
|
|
|
|
data.fColors, data.fPos,
|
2012-07-09 14:42:16 +00:00
|
|
|
data.fCount, tm, mapper);
|
|
|
|
}
|
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
|
2010-12-23 16:45:33 +00:00
|
|
|
SkShader::TileMode tm, SkUnitMapper* mapper);
|
2009-06-22 02:06:35 +00:00
|
|
|
static const GradMaker gGradMakers[] = {
|
2012-07-09 14:42:16 +00:00
|
|
|
MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical
|
2009-06-22 02:06:35 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
class GradientsGM : public GM {
|
|
|
|
public:
|
2012-08-23 18:14:13 +00:00
|
|
|
GradientsGM() {
|
2011-10-31 14:18:20 +00:00
|
|
|
this->setBGColor(0xFFDDDDDD);
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
protected:
|
|
|
|
SkString onShortName() {
|
|
|
|
return SkString("gradients");
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
virtual SkISize onISize() { return make_isize(640, 615); }
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
SkPoint pts[2] = {
|
|
|
|
{ 0, 0 },
|
|
|
|
{ SkIntToScalar(100), SkIntToScalar(100) }
|
|
|
|
};
|
|
|
|
SkShader::TileMode tm = SkShader::kClamp_TileMode;
|
|
|
|
SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
|
|
|
|
SkPaint paint;
|
|
|
|
paint.setAntiAlias(true);
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
|
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
|
|
|
|
canvas->save();
|
|
|
|
for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
|
|
|
|
SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
|
|
|
|
paint.setShader(shader);
|
|
|
|
canvas->drawRect(r, paint);
|
|
|
|
shader->unref();
|
|
|
|
canvas->translate(0, SkIntToScalar(120));
|
|
|
|
}
|
|
|
|
canvas->restore();
|
|
|
|
canvas->translate(SkIntToScalar(120), 0);
|
|
|
|
}
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
private:
|
|
|
|
typedef GM INHERITED;
|
|
|
|
};
|
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
// Based on the original gradient slide, but with perspective applied to the
|
|
|
|
// gradient shaders' local matrices
|
|
|
|
class GradientsLocalPerspectiveGM : public GM {
|
|
|
|
public:
|
2012-08-23 18:14:13 +00:00
|
|
|
GradientsLocalPerspectiveGM() {
|
2012-07-09 14:42:16 +00:00
|
|
|
this->setBGColor(0xFFDDDDDD);
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
protected:
|
|
|
|
SkString onShortName() {
|
|
|
|
return SkString("gradients_local_perspective");
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
virtual SkISize onISize() { return make_isize(640, 615); }
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
SkPoint pts[2] = {
|
|
|
|
{ 0, 0 },
|
|
|
|
{ SkIntToScalar(100), SkIntToScalar(100) }
|
|
|
|
};
|
|
|
|
SkShader::TileMode tm = SkShader::kClamp_TileMode;
|
|
|
|
SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
|
|
|
|
SkPaint paint;
|
|
|
|
paint.setAntiAlias(true);
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
|
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
|
|
|
|
canvas->save();
|
|
|
|
for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
|
|
|
|
SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
// apply an increasing y perspective as we move to the right
|
|
|
|
SkMatrix perspective;
|
|
|
|
perspective.setIdentity();
|
2012-08-20 18:58:26 +00:00
|
|
|
perspective.setPerspY(SkScalarDiv(SkIntToScalar((unsigned) i+1),
|
2012-07-09 14:42:16 +00:00
|
|
|
SkIntToScalar(500)));
|
2012-08-20 18:58:26 +00:00
|
|
|
perspective.setSkewX(SkScalarDiv(SkIntToScalar((unsigned) i+1),
|
2012-07-09 14:42:16 +00:00
|
|
|
SkIntToScalar(10)));
|
|
|
|
shader->setLocalMatrix(perspective);
|
|
|
|
|
|
|
|
paint.setShader(shader);
|
|
|
|
canvas->drawRect(r, paint);
|
|
|
|
shader->unref();
|
|
|
|
canvas->translate(0, SkIntToScalar(120));
|
|
|
|
}
|
|
|
|
canvas->restore();
|
|
|
|
canvas->translate(SkIntToScalar(120), 0);
|
|
|
|
}
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
private:
|
|
|
|
typedef GM INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Based on the original gradient slide, but with perspective applied to
|
|
|
|
// the view matrix
|
|
|
|
class GradientsViewPerspectiveGM : public GradientsGM {
|
|
|
|
protected:
|
|
|
|
SkString onShortName() {
|
|
|
|
return SkString("gradients_view_perspective");
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
virtual SkISize onISize() { return make_isize(640, 400); }
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
|
|
|
SkMatrix perspective;
|
|
|
|
perspective.setIdentity();
|
|
|
|
perspective.setPerspY(SkScalarDiv(SK_Scalar1, SkIntToScalar(1000)));
|
|
|
|
perspective.setSkewX(SkScalarDiv(SkIntToScalar(8), SkIntToScalar(25)));
|
2012-08-15 18:42:45 +00:00
|
|
|
canvas->concat(perspective);
|
2012-07-09 14:42:16 +00:00
|
|
|
INHERITED::onDraw(canvas);
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-07-09 14:42:16 +00:00
|
|
|
private:
|
|
|
|
typedef GradientsGM INHERITED;
|
|
|
|
};
|
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
/*
|
|
|
|
Inspired by this <canvas> javascript, where we need to detect that we are not
|
|
|
|
solving a quadratic equation, but must instead solve a linear (since our X^2
|
|
|
|
coefficient is 0)
|
|
|
|
|
|
|
|
ctx.fillStyle = '#f00';
|
|
|
|
ctx.fillRect(0, 0, 100, 50);
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
var g = ctx.createRadialGradient(-80, 25, 70, 0, 25, 150);
|
|
|
|
g.addColorStop(0, '#f00');
|
|
|
|
g.addColorStop(0.01, '#0f0');
|
|
|
|
g.addColorStop(0.99, '#0f0');
|
|
|
|
g.addColorStop(1, '#f00');
|
|
|
|
ctx.fillStyle = g;
|
|
|
|
ctx.fillRect(0, 0, 100, 50);
|
|
|
|
*/
|
|
|
|
class GradientsDegenrate2PointGM : public GM {
|
|
|
|
public:
|
|
|
|
GradientsDegenrate2PointGM() {}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
protected:
|
|
|
|
SkString onShortName() {
|
|
|
|
return SkString("gradients_degenerate_2pt");
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
|
|
|
virtual SkISize onISize() { return make_isize(320, 320); }
|
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
void drawBG(SkCanvas* canvas) {
|
|
|
|
canvas->drawColor(SK_ColorBLUE);
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
|
|
|
this->drawBG(canvas);
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorGREEN, SK_ColorRED };
|
|
|
|
SkScalar pos[] = { 0, SkFloatToScalar(0.01f), SkFloatToScalar(0.99f), SK_Scalar1 };
|
2011-07-21 15:50:33 +00:00
|
|
|
SkPoint c0;
|
|
|
|
c0.iset(-80, 25);
|
|
|
|
SkScalar r0 = SkIntToScalar(70);
|
|
|
|
SkPoint c1;
|
|
|
|
c1.iset(0, 25);
|
|
|
|
SkScalar r1 = SkIntToScalar(150);
|
2011-06-27 18:11:17 +00:00
|
|
|
SkShader* s = SkGradientShader::CreateTwoPointRadial(c0, r0, c1, r1, colors,
|
|
|
|
pos, SK_ARRAY_COUNT(pos),
|
|
|
|
SkShader::kClamp_TileMode);
|
|
|
|
SkPaint paint;
|
|
|
|
paint.setShader(s)->unref();
|
|
|
|
canvas->drawPaint(paint);
|
|
|
|
}
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
private:
|
|
|
|
typedef GM INHERITED;
|
|
|
|
};
|
|
|
|
|
2011-09-26 15:03:55 +00:00
|
|
|
/// Tests correctness of *optimized* codepaths in gradients.
|
|
|
|
|
|
|
|
class ClampedGradientsGM : public GM {
|
|
|
|
public:
|
|
|
|
ClampedGradientsGM() {}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
SkString onShortName() { return SkString("clamped_gradients"); }
|
|
|
|
|
|
|
|
virtual SkISize onISize() { return make_isize(640, 510); }
|
|
|
|
|
|
|
|
void drawBG(SkCanvas* canvas) {
|
|
|
|
canvas->drawColor(0xFFDDDDDD);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
|
|
|
this->drawBG(canvas);
|
|
|
|
|
|
|
|
SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(300) };
|
|
|
|
SkPaint paint;
|
|
|
|
paint.setAntiAlias(true);
|
|
|
|
|
|
|
|
SkPoint center;
|
|
|
|
center.iset(0, 300);
|
|
|
|
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
|
|
|
|
SkShader* shader = SkGradientShader::CreateRadial(
|
|
|
|
SkPoint(center),
|
2011-10-06 19:37:39 +00:00
|
|
|
SkIntToScalar(200), gColors, NULL, 5,
|
2011-09-26 15:03:55 +00:00
|
|
|
SkShader::kClamp_TileMode, NULL);
|
|
|
|
paint.setShader(shader);
|
|
|
|
canvas->drawRect(r, paint);
|
|
|
|
shader->unref();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
typedef GM INHERITED;
|
|
|
|
};
|
|
|
|
|
2012-01-30 20:00:13 +00:00
|
|
|
/// Checks quality of large radial gradients, which may display
|
|
|
|
/// some banding.
|
|
|
|
|
|
|
|
class RadialGradientGM : public GM {
|
|
|
|
public:
|
|
|
|
RadialGradientGM() {}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
SkString onShortName() { return SkString("radial_gradient"); }
|
2012-01-31 14:44:13 +00:00
|
|
|
virtual SkISize onISize() { return make_isize(1280, 1280); }
|
2012-01-30 20:00:13 +00:00
|
|
|
void drawBG(SkCanvas* canvas) {
|
|
|
|
canvas->drawColor(0xFF000000);
|
|
|
|
}
|
|
|
|
virtual void onDraw(SkCanvas* canvas) {
|
2012-01-31 14:44:13 +00:00
|
|
|
const SkISize dim = this->getISize();
|
|
|
|
|
2012-01-30 20:00:13 +00:00
|
|
|
this->drawBG(canvas);
|
2012-08-23 18:14:13 +00:00
|
|
|
|
2012-01-30 20:00:13 +00:00
|
|
|
SkPaint paint;
|
|
|
|
paint.setDither(true);
|
|
|
|
SkPoint center;
|
2012-01-31 14:44:13 +00:00
|
|
|
center.set(SkIntToScalar(dim.width())/2, SkIntToScalar(dim.height())/2);
|
|
|
|
SkScalar radius = SkIntToScalar(dim.width())/2;
|
|
|
|
const SkColor colors[] = { 0x7f7f7f7f, 0x7f7f7f7f, 0xb2000000 };
|
2012-04-06 20:01:46 +00:00
|
|
|
const SkScalar pos[] = { SkFloatToScalar(0.0f),
|
|
|
|
SkFloatToScalar(0.35f),
|
|
|
|
SkFloatToScalar(1.0f) };
|
2012-01-30 20:00:13 +00:00
|
|
|
SkShader* shader =
|
|
|
|
SkGradientShader::CreateRadial(center, radius, colors,
|
2012-01-31 14:44:13 +00:00
|
|
|
pos, SK_ARRAY_COUNT(pos),
|
|
|
|
SkShader::kClamp_TileMode);
|
2012-01-30 20:00:13 +00:00
|
|
|
paint.setShader(shader)->unref();
|
2012-01-31 14:44:13 +00:00
|
|
|
SkRect r = {
|
|
|
|
0, 0, SkIntToScalar(dim.width()), SkIntToScalar(dim.height())
|
|
|
|
};
|
2012-01-30 20:00:13 +00:00
|
|
|
canvas->drawRect(r, paint);
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
typedef GM INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2011-09-26 15:03:55 +00:00
|
|
|
|
2009-06-22 02:06:35 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
static GM* MyFactory(void*) { return new GradientsGM; }
|
|
|
|
static GMRegistry reg(MyFactory);
|
|
|
|
|
2011-06-27 18:11:17 +00:00
|
|
|
static GM* MyFactory2(void*) { return new GradientsDegenrate2PointGM; }
|
|
|
|
static GMRegistry reg2(MyFactory2);
|
|
|
|
|
2011-09-26 15:03:55 +00:00
|
|
|
static GM* MyFactory3(void*) { return new ClampedGradientsGM; }
|
|
|
|
static GMRegistry reg3(MyFactory3);
|
|
|
|
|
2012-01-30 20:00:13 +00:00
|
|
|
static GM* MyFactory4(void*) { return new RadialGradientGM; }
|
|
|
|
static GMRegistry reg4(MyFactory4);
|
2012-07-09 14:42:16 +00:00
|
|
|
|
|
|
|
static GM* MyFactory5(void*) { return new GradientsLocalPerspectiveGM; }
|
|
|
|
static GMRegistry reg5(MyFactory5);
|
|
|
|
|
|
|
|
static GM* MyFactory6(void*) { return new GradientsViewPerspectiveGM; }
|
|
|
|
static GMRegistry reg6(MyFactory6);
|
2009-06-22 02:06:35 +00:00
|
|
|
}
|