AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Move SkShader::fLocalMatrix into SkShader constructor.

Browse Source 
As a first step towards removing SkShader::setLocalMatrix, which will make
SkShader thread-safe, remove calls to setLocalMatrix that happen immediately
after the shader is being created. Instead, pass the matrix into the constructor
or factory method.

BUG=skia:1976
R=scroggo@google.com, reed@google.com, skyostil@google.com, mtklein@google.com

Author: dominikg@chromium.org

Review URL: https://codereview.chromium.org/245963010

git-svn-id: http://skia.googlecode.com/svn/trunk@14401 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
commit-bot@chromium.org 2014-04-28 14:55:39 +00:00
parent c76a4b2a81
commit 9c9005a347
55 changed files with 322 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gm/aarectmodes.cpp
View File

@ -113,13 +113,13 @@ static SkShader* make_bg_shader() {
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
0xCC, 0xCC);
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
return s;
}

10
gm/bigmatrix.cpp
View File

@ -67,14 +67,14 @@ protected:
pixels[3] = SkPackARGB32(0xFF, 0x00, 0x00, 0xFF);
pt.set(30 * SK_Scalar1, 30 * SK_Scalar1);
m.mapPoints(&pt, 1);
SkShader* shader = SkShader::CreateBitmapShader(
bmp,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix s;
s.reset();
s.setScale(SK_Scalar1 / 1000, SK_Scalar1 / 1000);
shader->setLocalMatrix(s);
SkShader* shader = SkShader::CreateBitmapShader(
bmp,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&s);
paint.setShader(shader)->unref();
paint.setAntiAlias(false);
paint.setFilterLevel(SkPaint::kLow_FilterLevel);

7
gm/bitmapshader.cpp
View File

@ -35,8 +35,7 @@ static void draw_mask(SkBitmap* bm) {
canvas.drawCircle(10, 10, 10, circlePaint);
}
static void adopt_shader(SkPaint* paint, SkShader* shader, SkMatrix s) {
shader->setLocalMatrix(s);
static void adopt_shader(SkPaint* paint, SkShader* shader) {
paint->setShader(shader);
SkSafeUnref(shader);
}
@ -72,7 +71,7 @@ protected:
canvas->save();
adopt_shader(&paint, SkShader::CreateBitmapShader(fBitmap, SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode), s);
SkShader::kClamp_TileMode, &s));
// draw the shader with a bitmap mask
canvas->drawBitmap(fMask, 0, 0, &paint);
@ -94,7 +93,7 @@ protected:
canvas->translate(0, 25);
adopt_shader(&paint, SkShader::CreateBitmapShader(fMask, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode), s);
SkShader::kRepeat_TileMode, &s));
paint.setColor(SK_ColorRED);
// draw the mask using the shader and a color

9
gm/clippedbitmapshaders.cpp
View File

@ -78,15 +78,14 @@ protected:
virtual void onDraw(SkCanvas* canvas) {
SkBitmap bmp = create_bitmap();
SkShader* shader = SkShader::CreateBitmapShader(
bmp, fMode, fMode);
SkPaint paint;
SkMatrix s;
s.reset();
s.setScale(8, 8);
s.postTranslate(SLIDE_SIZE / 2, SLIDE_SIZE / 2);
shader->setLocalMatrix(s);
SkShader* shader = SkShader::CreateBitmapShader(
bmp, fMode, fMode, &s);
SkPaint paint;
paint.setShader(shader)->unref();
if (fHQ) {

5
gm/colortype.cpp
View File

@ -17,11 +17,10 @@ public:
SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE,
SK_ColorMAGENTA, SK_ColorCYAN, SK_ColorYELLOW
};
SkShader* s = SkGradientShader::CreateSweep(0,0, colors, NULL,
SK_ARRAY_COUNT(colors));
SkMatrix local;
local.setRotate(180);
s->setLocalMatrix(local);
SkShader* s = SkGradientShader::CreateSweep(0,0, colors, NULL,
SK_ARRAY_COUNT(colors), NULL, 0, &local);
SkPaint paint;
paint.setAntiAlias(true);

12
gm/convexpolyclip.cpp
View File

@ -38,15 +38,15 @@ static SkBitmap make_bmp(int w, int h) {
SK_Scalar1};
SkPaint paint;
paint.setShader(SkGradientShader::CreateRadial(
pt, radius,
colors, pos,
SK_ARRAY_COUNT(colors),
SkShader::kRepeat_TileMode))->unref();
SkRect rect = SkRect::MakeWH(wScalar, hScalar);
SkMatrix mat = SkMatrix::I();
for (int i = 0; i < 4; ++i) {
paint.getShader()->setLocalMatrix(mat);
paint.setShader(SkGradientShader::CreateRadial(
pt, radius,
colors, pos,
SK_ARRAY_COUNT(colors),
SkShader::kRepeat_TileMode,
NULL, 0, &mat))->unref();
canvas.drawRect(rect, paint);
rect.inset(wScalar / 8, hScalar / 8);
mat.preTranslate(6 * wScalar, 6 * hScalar);

12
gm/drawbitmaprect.cpp
View File

@ -55,15 +55,15 @@ static void makebm(SkBitmap* bm, int w, int h) {
SK_Scalar1};
SkPaint paint;
paint.setShader(SkGradientShader::CreateRadial(
pt, radius,
colors, pos,
SK_ARRAY_COUNT(colors),
SkShader::kRepeat_TileMode))->unref();
SkRect rect = SkRect::MakeWH(wScalar, hScalar);
SkMatrix mat = SkMatrix::I();
for (int i = 0; i < 4; ++i) {
paint.getShader()->setLocalMatrix(mat);
paint.setShader(SkGradientShader::CreateRadial(
pt, radius,
colors, pos,
SK_ARRAY_COUNT(colors),
SkShader::kRepeat_TileMode,
NULL, 0, &mat))->unref();
canvas.drawRect(rect, paint);
rect.inset(wScalar / 8, hScalar / 8);
mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);

3
gm/giantbitmap.cpp
View File

@ -95,7 +95,6 @@ protected:
virtual void onDraw(SkCanvas* canvas) {
SkPaint paint;
SkShader* s = SkShader::CreateBitmapShader(getBitmap(), fMode, fMode);
SkMatrix m;
if (fDoRotate) {
@ -106,7 +105,7 @@ protected:
SkScalar scale = 11*SK_Scalar1/12;
m.setScale(scale, scale);
}
s->setLocalMatrix(m);
SkShader* s = SkShader::CreateBitmapShader(getBitmap(), fMode, fMode, &m);
paint.setShader(s)->unref();
paint.setFilterLevel(fDoFilter ? SkPaint::kLow_FilterLevel : SkPaint::kNone_FilterLevel);

14
gm/gradient_matrix.cpp
View File

@ -61,21 +61,22 @@ static const SkScalar TESTGRID_Y = SkIntToScalar(200);
static const int IMAGES_X = 4; // number of images per row
static SkShader* make_linear_gradient(const SkPoint pts[2]) {
static SkShader* make_linear_gradient(const SkPoint pts[2], const SkMatrix& localMatrix) {
return SkGradientShader::CreateLinear(pts, gColors, NULL, SK_ARRAY_COUNT(gColors),
SkShader::kClamp_TileMode, NULL);
SkShader::kClamp_TileMode, NULL, 0, &localMatrix);
}
static SkShader* make_radial_gradient(const SkPoint pts[2]) {
static SkShader* make_radial_gradient(const SkPoint pts[2], const SkMatrix& localMatrix) {
SkPoint center;
center.set(SkScalarAve(pts[0].fX, pts[1].fX),
SkScalarAve(pts[0].fY, pts[1].fY));
float radius = (center - pts[0]).length();
return SkGradientShader::CreateRadial(center, radius, gColors, NULL, SK_ARRAY_COUNT(gColors),
SkShader::kClamp_TileMode, NULL);
SkShader::kClamp_TileMode, NULL, 0, &localMatrix);
}
static void draw_gradients(SkCanvas* canvas, SkShader* (*makeShader)(const SkPoint[2]),
static void draw_gradients(SkCanvas* canvas,
SkShader* (*makeShader)(const SkPoint[2], const SkMatrix&),
const SkPoint ptsArray[][2], int numImages) {
// Use some nice prime numbers for the rectangle and matrix with
// different scaling along the x and y axes (which is the bug this
@ -97,8 +98,7 @@ static void draw_gradients(SkCanvas* canvas, SkShader* (*makeShader)(const SkPoi
}
// Setup shader and draw.
SkAutoTUnref<SkShader> shader(makeShader(*ptsArray));
shader->setLocalMatrix(shaderMat);
SkAutoTUnref<SkShader> shader(makeShader(*ptsArray, shaderMat));
SkPaint paint;
paint.setShader(shader);

40
gm/gradients.cpp
View File

@ -40,31 +40,35 @@ static const GradData gGradData[] = {
};
static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper, 0, &localMatrix);
}
static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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);
data.fPos, data.fCount, tm, mapper, 0, &localMatrix);
}
static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
SkShader::TileMode, SkUnitMapper* mapper) {
SkShader::TileMode, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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);
data.fPos, data.fCount, mapper, 0, &localMatrix);
}
static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
SkScalarAve(pts[0].fY, pts[1].fY));
@ -73,11 +77,13 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
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);
data.fColors, data.fPos, data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -86,11 +92,13 @@ static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
return SkGradientShader::CreateTwoPointConical(center1, radius1,
center0, radius0,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper);
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix);
static const GradMaker gGradMakers[] = {
MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical
};
@ -125,15 +133,15 @@ protected:
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);
SkMatrix scale = SkMatrix::I();
if (i == 5) { // if the clamp case
SkMatrix scale;
scale.setScale(0.5f, 0.5f);
scale.postTranslate(25.f, 25.f);
shader->setLocalMatrix(scale);
}
SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL, scale);
paint.setShader(shader);
canvas->drawRect(r, paint);
shader->unref();
@ -178,8 +186,6 @@ protected:
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);
// apply an increasing y perspective as we move to the right
SkMatrix perspective;
perspective.setIdentity();
@ -188,7 +194,7 @@ protected:
perspective.setSkewX(SkScalarDiv(SkIntToScalar((unsigned) i+1),
SkIntToScalar(10)));
shader->setLocalMatrix(perspective);
SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL, perspective);
paint.setShader(shader);
canvas->drawRect(r, paint);

145
gm/gradients_2pt_conical.cpp
View File

@ -38,7 +38,8 @@ static const GradData gGradData[] = {
};
static SkShader* Make2ConicalOutside(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -47,11 +48,13 @@ static SkShader* Make2ConicalOutside(const SkPoint pts[2], const GradData& data,
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalOutsideFlip(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -60,89 +63,97 @@ static SkShader* Make2ConicalOutsideFlip(const SkPoint pts[2], const GradData& d
return SkGradientShader::CreateTwoPointConical(center1, radius1,
center0, radius0,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalInside(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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);
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,
0, &localMatrix);
}
static SkShader* Make2ConicalInsideFlip(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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(
center0, (pts[1].fX - pts[0].fX) / 2,
center1, (pts[1].fX - pts[0].fX) / 7,
data.fColors, data.fPos, data.fCount, tm, mapper);
return SkGradientShader::CreateTwoPointConical(center0, (pts[1].fX - pts[0].fX) / 2,
center1, (pts[1].fX - pts[0].fX) / 7,
data.fColors, data.fPos, data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalInsideCenter(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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(
center0, (pts[1].fX - pts[0].fX) / 7,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper);
return SkGradientShader::CreateTwoPointConical(center0, (pts[1].fX - pts[0].fX) / 7,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalZeroRad(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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, 0.f,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper);
return SkGradientShader::CreateTwoPointConical(center1, 0.f,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalZeroRadFlip(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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) / 2,
center0, 0.f,
data.fColors, data.fPos, data.fCount, tm, mapper);
return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 2,
center0, 0.f,
data.fColors, data.fPos, data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalZeroRadCenter(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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(
center0, 0.f,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper);
return SkGradientShader::CreateTwoPointConical(center0, 0.f,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalZeroRadOutside(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = 0.f;
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -151,11 +162,13 @@ static SkShader* Make2ConicalZeroRadOutside(const SkPoint pts[2], const GradData
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalZeroRadFlipOutside(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = 0.f;
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -164,11 +177,13 @@ static SkShader* Make2ConicalZeroRadFlipOutside(const SkPoint pts[2], const Grad
return SkGradientShader::CreateTwoPointConical(center1, radius1,
center0, radius0,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalEdgeX(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -178,11 +193,13 @@ static SkShader* Make2ConicalEdgeX(const SkPoint pts[2], const GradData& data,
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalEdgeY(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -192,10 +209,12 @@ static SkShader* Make2ConicalEdgeY(const SkPoint pts[2], const GradData& data,
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalZeroRadEdgeX(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = 0.f;
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -205,11 +224,13 @@ static SkShader* Make2ConicalZeroRadEdgeX(const SkPoint pts[2], const GradData&
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalZeroRadEdgeY(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = 0.f;
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -219,11 +240,13 @@ static SkShader* Make2ConicalZeroRadEdgeY(const SkPoint pts[2], const GradData&
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalTouchX(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -233,11 +256,13 @@ static SkShader* Make2ConicalTouchX(const SkPoint pts[2], const GradData& data,
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalTouchY(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
SkPoint center0, center1;
SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@ -247,24 +272,27 @@ static SkShader* Make2ConicalTouchY(const SkPoint pts[2], const GradData& data,
return SkGradientShader::CreateTwoPointConical(center0, radius0,
center1, radius1,
data.fColors, data.fPos,
data.fCount, tm, mapper);
data.fCount, tm, mapper,
0, &localMatrix);
}
static SkShader* Make2ConicalInsideSmallRad(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper) {
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix) {
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(
center0, 0.0000000000000000001f,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper);
return SkGradientShader::CreateTwoPointConical(center0, 0.0000000000000000001f,
center0, (pts[1].fX - pts[0].fX) / 2,
data.fColors, data.fPos, data.fCount, tm, mapper,
0, &localMatrix);
}
typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
SkShader::TileMode tm, SkUnitMapper* mapper);
SkShader::TileMode tm, SkUnitMapper* mapper,
const SkMatrix& localMatrix);
static const GradMaker gGradMakersOutside[] = {
Make2ConicalOutside, Make2ConicalOutsideFlip,
@ -336,15 +364,14 @@ protected:
for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
canvas->save();
for (int j = 0; j < count; j++) {
SkShader* shader = gradMaker[j](pts, gGradData[i], tm, NULL);
SkMatrix scale = SkMatrix::I();
if (i == 3) { // if the clamp case
SkMatrix scale;
scale.setScale(0.5f, 0.5f);
scale.postTranslate(25.f, 25.f);
shader->setLocalMatrix(scale);
}
SkShader* shader = gradMaker[j](pts, gGradData[i], tm, NULL, scale);
paint.setShader(shader);
canvas->drawRect(r, paint);
shader->unref();

10
gm/hairmodes.cpp
View File

@ -64,14 +64,12 @@ static SkShader* make_bg_shader() {
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC, 0xCC, 0xCC);
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
return s;
return SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
}
namespace skiagm {

8
gm/mixedxfermodes.cpp
View File

@ -86,13 +86,13 @@ protected:
SkBitmap bitmap;
bitmap.allocN32Pixels(2, 2);
memcpy(bitmap.getPixels(), kCheckerPixelData, sizeof(kCheckerPixelData));
SkMatrix lm;
lm.setScale(SkIntToScalar(20), SkIntToScalar(20));
fBG.reset(SkShader::CreateBitmapShader(bitmap,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode));
SkShader::kRepeat_TileMode,
&lm));
}
SkMatrix lm;
lm.setScale(SkIntToScalar(20), SkIntToScalar(20));
fBG->setLocalMatrix(lm);
SkPaint bgPaint;
bgPaint.setShader(fBG.get());

10
gm/shaderbounds.cpp
View File

@ -9,7 +9,8 @@
namespace skiagm {
static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate) {
static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate,
const SkMatrix& localMatrix) {
SkPoint pts[2] = { {0, 0}, {width, height}};
SkColor colors[2] = {SK_ColorRED, SK_ColorGREEN};
if (alternate) {
@ -18,7 +19,7 @@ static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate) {
colors[1] = SK_ColorYELLOW;
}
return SkGradientShader::CreateLinear(pts, colors, NULL, 2,
SkShader::kClamp_TileMode, NULL);
SkShader::kClamp_TileMode, NULL, 0, &localMatrix);
}
///////////////////////////////////////////////////////////////////////////////
@ -26,7 +27,7 @@ static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate) {
class ShaderBoundsGM : public GM {
public:
typedef SkShader* (*ShaderGenFunc)(SkScalar width, SkScalar height,
bool alternate);
bool alternate, const SkMatrix& localMatrix);
ShaderBoundsGM(ShaderGenFunc maker, const SkString& name)
: fShaderMaker(maker),
fName(name) {
@ -80,10 +81,9 @@ protected:
}
SkScalar shaderWidth = SkScalarDiv(SkIntToScalar(width), scale);
SkScalar shaderHeight = SkScalarDiv(SkIntToScalar(height), scale);
SkShader* shader = fShaderMaker(shaderWidth, shaderHeight, background);
SkMatrix shaderScale;
shaderScale.setScale(scale, scale);
shader->setLocalMatrix(shaderScale);
SkShader* shader = fShaderMaker(shaderWidth, shaderHeight, background, shaderScale);
return shader;
}

9
gm/shadertext2.cpp
View File

@ -95,14 +95,10 @@ protected:
makebm(&bmp, kPointSize / 2, kPointSize / 2);
}
SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(bmp,
SkShader::kMirror_TileMode,
SkShader::kRepeat_TileMode));
SkPaint fillPaint;
fillPaint.setAntiAlias(true);
fillPaint.setTextSize(SkIntToScalar(kPointSize));
fillPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
fillPaint.setShader(shader);
SkPaint outlinePaint;
outlinePaint.setAntiAlias(true);
@ -158,7 +154,10 @@ protected:
canvas->translate(0, kPadY / 2 + kPointSize);
columnH += kPadY / 2 + kPointSize;
for (int lm = 0; lm < localMatrices.count(); ++lm) {
shader->setLocalMatrix(localMatrices[lm].fMatrix);
paint.setShader(SkShader::CreateBitmapShader(bmp,
SkShader::kMirror_TileMode,
SkShader::kRepeat_TileMode,
&localMatrices[lm].fMatrix));
canvas->save();
canvas->concat(matrices[m].fMatrix);

9
gm/shadertext3.cpp
View File

@ -100,14 +100,15 @@ protected:
int i = 0;
for (size_t tm0 = 0; tm0 < SK_ARRAY_COUNT(kTileModes); ++tm0) {
for (size_t tm1 = 0; tm1 < SK_ARRAY_COUNT(kTileModes); ++tm1) {
SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(fBmp,
kTileModes[tm0],
kTileModes[tm1]));
SkMatrix localM;
localM.setTranslate(5.f, 5.f);
localM.postRotate(20);
localM.postScale(1.15f, .85f);
shader->setLocalMatrix(localM);
SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(fBmp,
kTileModes[tm0],
kTileModes[tm1],
&localM));
SkPaint fillPaint;
fillPaint.setAntiAlias(true);

8
gm/xfermodes.cpp
View File

@ -216,12 +216,12 @@ protected:
const SkScalar w = SkIntToScalar(W);
const SkScalar h = SkIntToScalar(H);
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
SkPaint labelP;
labelP.setAntiAlias(true);

8
gm/xfermodes2.cpp
View File

@ -96,12 +96,12 @@ private:
bg.allocN32Pixels(2, 2, true);
memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
fBG.reset(SkShader::CreateBitmapShader(bg,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode));
SkMatrix lm;
lm.setScale(SkIntToScalar(16), SkIntToScalar(16));
fBG->setLocalMatrix(lm);
fBG.reset(SkShader::CreateBitmapShader(bg,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&lm));
SkBitmap dstBmp;
dstBmp.allocN32Pixels(kSize, kSize);

8
gm/xfermodes3.cpp
View File

@ -195,12 +195,12 @@ private:
SkAutoLockPixels bgAlp(bg);
memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
fBGShader.reset(SkShader::CreateBitmapShader(bg,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode));
SkMatrix lm;
lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize));
fBGShader->setLocalMatrix(lm);
fBGShader.reset(SkShader::CreateBitmapShader(bg,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&lm));
SkPaint bmpPaint;
static const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 };

5
include/core/SkShader.h
View File

@ -34,7 +34,7 @@ class SK_API SkShader : public SkFlattenable {
public:
SK_DECLARE_INST_COUNT(SkShader)
SkShader();
SkShader(const SkMatrix* localMatrix = NULL);
virtual ~SkShader();
/**
@ -371,7 +371,8 @@ public:
* @return Returns a new shader object. Note: this function never returns null.
*/
static SkShader* CreateBitmapShader(const SkBitmap& src,
TileMode tmx, TileMode tmy);
TileMode tmx, TileMode tmy,
const SkMatrix* localMatrix = NULL);
/** Call this to create a new shader that will draw with the specified picture.
*

15
include/effects/SkGradientShader.h
View File

@ -49,7 +49,8 @@ public:
const SkColor colors[], const SkScalar pos[], int count,
SkShader::TileMode mode,
SkUnitMapper* mapper = NULL,
uint32_t flags = 0);
uint32_t flags = 0,
const SkMatrix* localMatrix = NULL);
/** Returns a shader that generates a radial gradient given the center and radius.
<p />
@ -72,7 +73,8 @@ public:
const SkColor colors[], const SkScalar pos[], int count,
SkShader::TileMode mode,
SkUnitMapper* mapper = NULL,
uint32_t flags = 0);
uint32_t flags = 0,
const SkMatrix* localMatrix = NULL);
/** Returns a shader that generates a radial gradient given the start position, start radius, end position and end radius.
<p />
@ -102,7 +104,8 @@ public:
const SkScalar pos[], int count,
SkShader::TileMode mode,
SkUnitMapper* mapper = NULL,
uint32_t flags = 0);
uint32_t flags = 0,
const SkMatrix* localMatrix = NULL);
/**
* Returns a shader that generates a conical gradient given two circles, or
@ -118,7 +121,8 @@ public:
const SkScalar pos[], int count,
SkShader::TileMode mode,
SkUnitMapper* mapper = NULL,
uint32_t flags = 0);
uint32_t flags = 0,
const SkMatrix* localMatrix = NULL);
/** Returns a shader that generates a sweep gradient given a center.
<p />
@ -139,7 +143,8 @@ public:
static SkShader* CreateSweep(SkScalar cx, SkScalar cy,
const SkColor colors[], const SkScalar pos[],
int count, SkUnitMapper* mapper = NULL,
uint32_t flags = 0);
uint32_t flags = 0,
const SkMatrix* localMatrix = NULL);
SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
};

11
samplecode/SampleAARectModes.cpp
View File

@ -68,14 +68,13 @@ static SkShader* make_bg_shader() {
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
0xCC, 0xCC);
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
return s;
return SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
}
class AARectsModesView : public SampleView {

10
samplecode/SampleCamera.cpp
View File

@ -33,15 +33,15 @@ public:
str.printf("/skimages/elephant%d.jpeg", i);
SkBitmap bm;
if (SkImageDecoder::DecodeFile(str.c_str(), &bm)) {
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode);
SkRect src = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
SkRect dst = { -150, -150, 150, 150 };
SkMatrix matrix;
matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
s->setLocalMatrix(matrix);
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode,
&matrix);
*fShaders.append() = s;
} else {
break;

7
samplecode/SampleColorFilter.cpp
View File

@ -92,13 +92,10 @@ SkShader* createChecker() {
bm.lockPixels();
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = SkPreMultiplyColor(0xFFFFFFFF);
*bm.getAddr32(0, 1) = *bm.getAddr32(1, 0) = SkPreMultiplyColor(0xFFCCCCCC);
SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(12, 12);
s->setLocalMatrix(m);
return s;
return SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &m);
}
static SkBitmap createBitmap(int n) {

3
samplecode/SampleDash.cpp
View File

@ -28,8 +28,7 @@ static void setBitmapDash(SkPaint* paint, int width) {
matrix.setScale(SkIntToScalar(width), SK_Scalar1);
SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kClamp_TileMode);
s->setLocalMatrix(matrix);
SkShader::kClamp_TileMode, &matrix);
paint->setShader(s)->unref();
}

7
samplecode/SampleFatBits.cpp
View File

@ -43,13 +43,10 @@ static SkShader* createChecker() {
bm.lockPixels();
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = SkPreMultiplyColor(colors[0]);
*bm.getAddr32(0, 1) = *bm.getAddr32(1, 0) = SkPreMultiplyColor(colors[1]);
SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(12, 12);
s->setLocalMatrix(m);
return s;
return SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &m);
}
class FatBits {

11
samplecode/SampleHairModes.cpp
View File

@ -66,14 +66,13 @@ static SkShader* make_bg_shader() {
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC, 0xCC, 0xCC);
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
return s;
return SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
}
class HairModesView : public SampleView {

16
samplecode/SampleLayers.cpp
View File

@ -27,10 +27,11 @@
#include "SkXfermode.h"
#include "SkDrawFilter.h"
static void make_paint(SkPaint* paint) {
static void make_paint(SkPaint* paint, const SkMatrix& localMatrix) {
SkColor colors[] = { 0, SK_ColorWHITE };
SkPoint pts[] = { { 0, 0 }, { 0, SK_Scalar1*20 } };
SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode,
NULL, 0, &localMatrix);
paint->setShader(s)->unref();
paint->setXfermodeMode(SkXfermode::kDstIn_Mode);
@ -104,19 +105,16 @@ static void test_fade(SkCanvas* canvas) {
dump_layers("outside layer alpha", canvas);
// now apply an effect
SkMatrix m;
m.setScale(SK_Scalar1, -SK_Scalar1);
m.postTranslate(0, SkIntToScalar(100));
SkPaint paint;
make_paint(&paint);
make_paint(&paint, m);
r.set(0, 0, SkIntToScalar(100), SkIntToScalar(20));
// SkDebugf("--------- draw top grad\n");
canvas->drawRect(r, paint);
SkMatrix m;
SkShader* s = paint.getShader();
m.setScale(SK_Scalar1, -SK_Scalar1);
m.postTranslate(0, SkIntToScalar(100));
s->setLocalMatrix(m);
r.fTop = SkIntToScalar(80);
r.fBottom = SkIntToScalar(100);
// SkDebugf("--------- draw bot grad\n");

8
samplecode/SampleXfermodesBlur.cpp
View File

@ -151,12 +151,12 @@ protected:
const SkScalar w = SkIntToScalar(W);
const SkScalar h = SkIntToScalar(H);
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
SkPaint labelP;
labelP.setAntiAlias(true);

8
src/animator/SkDrawGradient.cpp
View File

@ -175,9 +175,9 @@ SkShader* SkDrawLinearGradient::getShader() {
if (addPrelude() == 0 || points.count() != 4)
return NULL;
SkShader* shader = SkGradientShader::CreateLinear((SkPoint*)points.begin(),
fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode, fUnitMapper);
fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode,
fUnitMapper, 0, getMatrix());
SkAutoTDelete<SkShader> autoDel(shader);
addPostlude(shader);
(void)autoDel.detach();
return shader;
}
@ -210,9 +210,9 @@ SkShader* SkDrawRadialGradient::getShader() {
if (addPrelude() == 0)
return NULL;
SkShader* shader = SkGradientShader::CreateRadial(center,
radius, fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode, fUnitMapper);
radius, fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode,
fUnitMapper, 0, getMatrix());
SkAutoTDelete<SkShader> autoDel(shader);
addPostlude(shader);
(void)autoDel.detach();
return shader;
}

9
src/animator/SkDrawShader.cpp
View File

@ -36,9 +36,8 @@ bool SkDrawShader::add() {
return false;
}
void SkDrawShader::addPostlude(SkShader* shader) {
if (matrix)
shader->setLocalMatrix(matrix->getMatrix());
SkMatrix* SkDrawShader::getMatrix() {
return matrix ? &matrix->getMatrix() : NULL;
}
#if SK_USE_CONDENSED_INFO == 0
@ -75,9 +74,9 @@ SkShader* SkDrawBitmapShader::getShader() {
// draw-time from the paint
SkShader* shader = SkShader::CreateBitmapShader(image->fBitmap,
(SkShader::TileMode) tileMode,
(SkShader::TileMode) tileMode);
(SkShader::TileMode) tileMode,
getMatrix());
SkAutoTDelete<SkShader> autoDel(shader);
addPostlude(shader);
(void)autoDel.detach();
return shader;
}

2
src/animator/SkPaintPart.h
View File

@ -51,7 +51,7 @@ class SkDrawShader : public SkPaintPart {
virtual SkShader* getShader();
protected:
virtual bool add();
void addPostlude(SkShader* shader);
SkMatrix* getMatrix(); // returns NULL if matrix is NULL
SkDrawMatrix* matrix;
int /*SkShader::TileMode*/ tileMode;
};

4
src/core/SkBitmapDevice.cpp
View File

@ -381,11 +381,11 @@ void SkBitmapDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
// construct a shader, so we can call drawRect with the dst
SkShader* s = SkShader::CreateBitmapShader(*bitmapPtr,
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode);
SkShader::kClamp_TileMode,
&matrix);
if (NULL == s) {
return;
}
s->setLocalMatrix(matrix);
SkPaint paintWithShader(paint);
paintWithShader.setStyle(SkPaint::kFill_Style);

11
src/core/SkBitmapProcShader.cpp
View File

@ -31,8 +31,9 @@ bool SkBitmapProcShader::CanDo(const SkBitmap& bm, TileMode tx, TileMode ty) {
return false;
}
SkBitmapProcShader::SkBitmapProcShader(const SkBitmap& src,
TileMode tmx, TileMode tmy) {
SkBitmapProcShader::SkBitmapProcShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
const SkMatrix* localMatrix)
: INHERITED(localMatrix) {
fRawBitmap = src;
fTileModeX = (uint8_t)tmx;
fTileModeY = (uint8_t)tmy;
@ -347,7 +348,7 @@ static bool bitmapIsTooBig(const SkBitmap& bm) {
}
SkShader* CreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
SkShader::TileMode tmy, SkTBlitterAllocator* allocator) {
SkShader::TileMode tmy, const SkMatrix* localMatrix, SkTBlitterAllocator* allocator) {
SkShader* shader;
SkColor color;
if (src.isNull() || bitmapIsTooBig(src)) {
@ -365,9 +366,9 @@ SkShader* CreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
}
} else {
if (NULL == allocator) {
shader = SkNEW_ARGS(SkBitmapProcShader, (src, tmx, tmy));
shader = SkNEW_ARGS(SkBitmapProcShader, (src, tmx, tmy, localMatrix));
} else {
shader = allocator->createT<SkBitmapProcShader>(src, tmx, tmy);
shader = allocator->createT<SkBitmapProcShader>(src, tmx, tmy, localMatrix);
}
}
return shader;

5
src/core/SkBitmapProcShader.h
View File

@ -16,7 +16,8 @@
class SkBitmapProcShader : public SkShader {
public:
SkBitmapProcShader(const SkBitmap& src, TileMode tx, TileMode ty);
SkBitmapProcShader(const SkBitmap& src, TileMode tx, TileMode ty,
const SkMatrix* localMatrix = NULL);
// overrides from SkShader
virtual bool isOpaque() const SK_OVERRIDE;
@ -91,6 +92,6 @@ typedef SkSmallAllocator<3, sizeof(SkBitmapProcShader) +
// If alloc is non-NULL, it will be used to allocate the returned SkShader, and MUST outlive
// the SkShader.
SkShader* CreateBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode,
SkTBlitterAllocator* alloc);
const SkMatrix* localMatrix, SkTBlitterAllocator* alloc);
#endif

4
src/core/SkComposeShader.cpp
View File

@ -30,11 +30,11 @@ SkComposeShader::SkComposeShader(SkReadBuffer& buffer) :
INHERITED(buffer) {
fShaderA = buffer.readShader();
if (NULL == fShaderA) {
fShaderA = SkNEW_ARGS(SkColorShader, (0));
fShaderA = SkNEW_ARGS(SkColorShader, ((SkColor)0));
}
fShaderB = buffer.readShader();
if (NULL == fShaderB) {
fShaderB = SkNEW_ARGS(SkColorShader, (0));
fShaderB = SkNEW_ARGS(SkColorShader, ((SkColor)0));
}
fMode = buffer.readXfermode();
}

13
src/core/SkDraw.cpp
View File

@ -72,11 +72,12 @@ private:
*/
class SkAutoBitmapShaderInstall : SkNoncopyable {
public:
SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint)
SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint,
const SkMatrix* localMatrix = NULL)
: fPaint(paint) /* makes a copy of the paint */ {
fPaint.setShader(CreateBitmapShader(src, SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode,
&fAllocator));
localMatrix, &fAllocator));
// we deliberately left the shader with an owner-count of 2
SkASSERT(2 == fPaint.getShader()->getRefCnt());
}
@ -1374,18 +1375,16 @@ void SkDraw::drawSprite(const SkBitmap& bitmap, int x, int y,
}
}
SkAutoBitmapShaderInstall install(bitmap, paint);
const SkPaint& shaderPaint = install.paintWithShader();
SkMatrix matrix;
SkRect r;
// get a scalar version of our rect
r.set(bounds);
// tell the shader our offset
// create shader with offset
matrix.setTranslate(r.fLeft, r.fTop);
shaderPaint.getShader()->setLocalMatrix(matrix);
SkAutoBitmapShaderInstall install(bitmap, paint, &matrix);
const SkPaint& shaderPaint = install.paintWithShader();
SkDraw draw(*this);
matrix.reset();

3
src/core/SkPictureShader.cpp
View File

@ -91,13 +91,12 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& matrix) const {
canvas.scale(tileScale.width(), tileScale.height());
canvas.drawPicture(*fPicture);
fCachedBitmapShader.reset(CreateBitmapShader(bm, fTmx, fTmy));
fCachedTileScale = tileScale;
fCachedLocalMatrix = this->getLocalMatrix();
SkMatrix shaderMatrix = this->getLocalMatrix();
shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height());
fCachedBitmapShader->setLocalMatrix(shaderMatrix);
fCachedBitmapShader.reset(CreateBitmapShader(bm, fTmx, fTmy, &shaderMatrix));
}
// Increment the ref counter inside the mutex to ensure the returned pointer is still valid.

21
src/core/SkShader.cpp
View File

@ -15,8 +15,12 @@
#include "SkShader.h"
#include "SkWriteBuffer.h"
SkShader::SkShader() {
fLocalMatrix.reset();
SkShader::SkShader(const SkMatrix* localMatrix) {
if (localMatrix) {
fLocalMatrix = *localMatrix;
} else {
fLocalMatrix.reset();
}
}
SkShader::SkShader(SkReadBuffer& buffer)
@ -180,9 +184,9 @@ GrEffectRef* SkShader::asNewEffect(GrContext*, const SkPaint&) const {
return NULL;
}
SkShader* SkShader::CreateBitmapShader(const SkBitmap& src,
TileMode tmx, TileMode tmy) {
return ::CreateBitmapShader(src, tmx, tmy, NULL);
SkShader* SkShader::CreateBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
const SkMatrix* localMatrix) {
return ::CreateBitmapShader(src, tmx, tmy, localMatrix, NULL);
}
SkShader* SkShader::CreatePictureShader(SkPicture* src, TileMode tmx, TileMode tmy) {
@ -252,11 +256,8 @@ SkColorShader::ColorShaderContext::ColorShaderContext(const SkColorShader& shade
const SkMatrix& matrix)
: INHERITED(shader, device, paint, matrix)
{
SkColor color;
unsigned a;
color = shader.fColor;
a = SkAlphaMul(SkColorGetA(color), SkAlpha255To256(paint.getAlpha()));
SkColor color = shader.fColor;
unsigned a = SkAlphaMul(SkColorGetA(color), SkAlpha255To256(paint.getAlpha()));
unsigned r = SkColorGetR(color);
unsigned g = SkColorGetG(color);

10
src/core/SkSmallAllocator.h
View File

@ -96,6 +96,16 @@ public:
return static_cast<T*>(buf);
}
template<typename T, typename A1, typename A2, typename A3, typename A4>
T* createT(const A1& a1, const A2& a2, const A3& a3, const A4& a4) {
void* buf = this->reserveT<T>();
if (NULL == buf) {
return NULL;
}
SkNEW_PLACEMENT_ARGS(buf, T, (a1, a2, a3, a4));
return static_cast<T*>(buf);
}
/*
* Reserve a specified amount of space (must be enough space for one T).
* The space will be in fStorage if there is room, or on the heap otherwise.

6
src/effects/SkTileImageFilter.cpp
View File

@ -60,12 +60,12 @@ bool SkTileImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& src,
SkPaint paint;
paint.setXfermodeMode(SkXfermode::kSrc_Mode);
SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(subset,
SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode));
SkMatrix shaderMatrix;
shaderMatrix.setTranslate(SkIntToScalar(srcOffset.fX),
SkIntToScalar(srcOffset.fY));
shader->setLocalMatrix(shaderMatrix);
SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(subset,
SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
&shaderMatrix));
paint.setShader(shader);
canvas.translate(-dstRect.fLeft, -dstRect.fTop);
canvas.drawRect(dstRect, paint);

31
src/effects/gradients/SkGradientShader.cpp
View File

@ -12,7 +12,9 @@
#include "SkTwoPointConicalGradient.h"
#include "SkSweepGradient.h"
SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc) {
SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc, const SkMatrix* localMatrix)
: INHERITED(localMatrix)
{
SkASSERT(desc.fCount > 1);
fMapper = desc.fMapper;
@ -784,7 +786,8 @@ SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2],
const SkScalar pos[], int colorCount,
SkShader::TileMode mode,
SkUnitMapper* mapper,
uint32_t flags) {
uint32_t flags,
const SkMatrix* localMatrix) {
if (NULL == pts || NULL == colors || colorCount < 1) {
return NULL;
}
@ -792,7 +795,7 @@ SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2],
SkGradientShaderBase::Descriptor desc;
desc_init(&desc, colors, pos, colorCount, mode, mapper, flags);
return SkNEW_ARGS(SkLinearGradient, (pts, desc));
return SkNEW_ARGS(SkLinearGradient, (pts, desc, localMatrix));
}
SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius,
@ -800,7 +803,8 @@ SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius,
const SkScalar pos[], int colorCount,
SkShader::TileMode mode,
SkUnitMapper* mapper,
uint32_t flags) {
uint32_t flags,
const SkMatrix* localMatrix) {
if (radius <= 0 || NULL == colors || colorCount < 1) {
return NULL;
}
@ -808,7 +812,7 @@ SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius,
SkGradientShaderBase::Descriptor desc;
desc_init(&desc, colors, pos, colorCount, mode, mapper, flags);
return SkNEW_ARGS(SkRadialGradient, (center, radius, desc));
return SkNEW_ARGS(SkRadialGradient, (center, radius, desc, localMatrix));
}
SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start,
@ -820,7 +824,8 @@ SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start,
int colorCount,
SkShader::TileMode mode,
SkUnitMapper* mapper,
uint32_t flags) {
uint32_t flags,
const SkMatrix* localMatrix) {
if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) {
return NULL;
}
@ -829,7 +834,7 @@ SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start,
SkGradientShaderBase::Descriptor desc;
desc_init(&desc, colors, pos, colorCount, mode, mapper, flags);
return SkNEW_ARGS(SkTwoPointRadialGradient,
(start, startRadius, end, endRadius, desc));
(start, startRadius, end, endRadius, desc, localMatrix));
}
SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start,
@ -841,7 +846,8 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start,
int colorCount,
SkShader::TileMode mode,
SkUnitMapper* mapper,
uint32_t flags) {
uint32_t flags,
const SkMatrix* localMatrix) {
if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) {
return NULL;
}
@ -858,7 +864,7 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start,
if (!flipGradient) {
desc_init(&desc, colors, pos, colorCount, mode, mapper, flags);
return SkNEW_ARGS(SkTwoPointConicalGradient,
(start, startRadius, end, endRadius, flipGradient, desc));
(start, startRadius, end, endRadius, flipGradient, desc, localMatrix));
} else {
SkAutoSTArray<8, SkColor> colorsNew(colorCount);
SkAutoSTArray<8, SkScalar> posNew(colorCount);
@ -876,7 +882,7 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start,
}
return SkNEW_ARGS(SkTwoPointConicalGradient,
(end, endRadius, start, startRadius, flipGradient, desc));
(end, endRadius, start, startRadius, flipGradient, desc, localMatrix));
}
}
@ -884,7 +890,8 @@ SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy,
const SkColor colors[],
const SkScalar pos[],
int colorCount, SkUnitMapper* mapper,
uint32_t flags) {
uint32_t flags,
const SkMatrix* localMatrix) {
if (NULL == colors || colorCount < 1) {
return NULL;
}
@ -892,7 +899,7 @@ SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy,
SkGradientShaderBase::Descriptor desc;
desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, mapper, flags);
return SkNEW_ARGS(SkSweepGradient, (cx, cy, desc));
return SkNEW_ARGS(SkSweepGradient, (cx, cy, desc, localMatrix));
}
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader)

2
src/effects/gradients/SkGradientShaderPriv.h
View File

@ -99,7 +99,7 @@ public:
};
public:
SkGradientShaderBase(const Descriptor& desc);
SkGradientShaderBase(const Descriptor& desc, const SkMatrix* localMatrix);
virtual ~SkGradientShaderBase();
// The cache is initialized on-demand when getCache16/32 is called.

5
src/effects/gradients/SkLinearGradient.cpp
View File

@ -52,8 +52,9 @@ static void pts_to_unit_matrix(const SkPoint pts[2], SkMatrix* matrix) {
///////////////////////////////////////////////////////////////////////////////
SkLinearGradient::SkLinearGradient(const SkPoint pts[2], const Descriptor& desc)
: SkGradientShaderBase(desc)
SkLinearGradient::SkLinearGradient(const SkPoint pts[2], const Descriptor& desc,
const SkMatrix* localMatrix)
: SkGradientShaderBase(desc, localMatrix)
, fStart(pts[0])
, fEnd(pts[1]) {
pts_to_unit_matrix(pts, &fPtsToUnit);

2
src/effects/gradients/SkLinearGradient.h
View File

@ -13,7 +13,7 @@
class SkLinearGradient : public SkGradientShaderBase {
public:
SkLinearGradient(const SkPoint pts[2], const Descriptor&);
SkLinearGradient(const SkPoint pts[2], const Descriptor&, const SkMatrix* localMatrix);
virtual SkShader::Context* createContext(const SkBitmap&, const SkPaint&, const SkMatrix&,
void* storage) const SK_OVERRIDE;

4
src/effects/gradients/SkRadialGradient.cpp
View File

@ -146,8 +146,8 @@ void shadeSpan16_radial_repeat(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar d
/////////////////////////////////////////////////////////////////////
SkRadialGradient::SkRadialGradient(const SkPoint& center, SkScalar radius,
const Descriptor& desc)
: SkGradientShaderBase(desc),
const Descriptor& desc, const SkMatrix* localMatrix)
: SkGradientShaderBase(desc, localMatrix),
fCenter(center),
fRadius(radius)
{

3
src/effects/gradients/SkRadialGradient.h
View File

@ -13,7 +13,8 @@
class SkRadialGradient : public SkGradientShaderBase {
public:
SkRadialGradient(const SkPoint& center, SkScalar radius, const Descriptor&);
SkRadialGradient(const SkPoint& center, SkScalar radius, const Descriptor&,
const SkMatrix* localMatrix);
virtual SkShader::Context* createContext(const SkBitmap&, const SkPaint&, const SkMatrix&,
void* storage) const SK_OVERRIDE;

4
src/effects/gradients/SkSweepGradient.cpp
View File

@ -9,8 +9,8 @@
#include "SkSweepGradient.h"
SkSweepGradient::SkSweepGradient(SkScalar cx, SkScalar cy,
const Descriptor& desc)
: SkGradientShaderBase(desc)
const Descriptor& desc, const SkMatrix* localMatrix)
: SkGradientShaderBase(desc, localMatrix)
, fCenter(SkPoint::Make(cx, cy))
{
fPtsToUnit.setTranslate(-cx, -cy);

3
src/effects/gradients/SkSweepGradient.h
View File

@ -13,7 +13,8 @@
class SkSweepGradient : public SkGradientShaderBase {
public:
SkSweepGradient(SkScalar cx, SkScalar cy, const Descriptor&);
SkSweepGradient(SkScalar cx, SkScalar cy, const Descriptor&,
const SkMatrix* localMatrix);
virtual SkShader::Context* createContext(const SkBitmap&, const SkPaint&, const SkMatrix&,
void* storage) const SK_OVERRIDE;

5
src/effects/gradients/SkTwoPointConicalGradient.cpp
View File

@ -197,8 +197,9 @@ void SkTwoPointConicalGradient::init() {
SkTwoPointConicalGradient::SkTwoPointConicalGradient(
const SkPoint& start, SkScalar startRadius,
const SkPoint& end, SkScalar endRadius,
bool flippedGrad, const Descriptor& desc)
: SkGradientShaderBase(desc),
bool flippedGrad, const Descriptor& desc,
const SkMatrix* localMatrix)
: SkGradientShaderBase(desc, localMatrix),
fCenter1(start),
fCenter2(end),
fRadius1(startRadius),

3
src/effects/gradients/SkTwoPointConicalGradient.h
View File

@ -44,7 +44,8 @@ class SkTwoPointConicalGradient : public SkGradientShaderBase {
public:
SkTwoPointConicalGradient(const SkPoint& start, SkScalar startRadius,
const SkPoint& end, SkScalar endRadius,
bool flippedGrad, const Descriptor&);
bool flippedGrad, const Descriptor&,
const SkMatrix* localMatrix);
virtual SkShader::Context* createContext(const SkBitmap&, const SkPaint&, const SkMatrix&,

4
src/effects/gradients/SkTwoPointRadialGradient.cpp
View File

@ -170,8 +170,8 @@ void shadeSpan_twopoint_repeat(SkScalar fx, SkScalar dx,
SkTwoPointRadialGradient::SkTwoPointRadialGradient(
const SkPoint& start, SkScalar startRadius,
const SkPoint& end, SkScalar endRadius,
const Descriptor& desc)
: SkGradientShaderBase(desc),
const Descriptor& desc, const SkMatrix* localMatrix)
: SkGradientShaderBase(desc, localMatrix),
fCenter1(start),
fCenter2(end),
fRadius1(startRadius),

2
src/effects/gradients/SkTwoPointRadialGradient.h
View File

@ -15,7 +15,7 @@ class SkTwoPointRadialGradient : public SkGradientShaderBase {
public:
SkTwoPointRadialGradient(const SkPoint& start, SkScalar startRadius,
const SkPoint& end, SkScalar endRadius,
const Descriptor&);
const Descriptor&, const SkMatrix* localMatrix);
virtual BitmapType asABitmap(SkBitmap* bitmap,
SkMatrix* matrix,

3
src/gpu/SkGpuDevice.cpp
View File

@ -1202,8 +1202,7 @@ void SkGpuDevice::drawBitmapCommon(const SkDraw& draw,
SkPaint paintWithShader(paint);
paintWithShader.setShader(SkShader::CreateBitmapShader(*bitmapPtr,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode))->unref();
paintWithShader.getShader()->setLocalMatrix(localM);
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &localM))->unref();
SkRect dstRect = {0, 0, dstSize.fWidth, dstSize.fHeight};
this->drawRect(draw, dstRect, paintWithShader);

5
tests/DrawBitmapRectTest.cpp
View File

@ -197,8 +197,6 @@ static void test_wacky_bitmapshader(skiatest::Reporter* reporter,
bm.allocN32Pixels(width, height);
bm.eraseColor(SK_ColorRED);
SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
matrix.setAll(0.0078740157f,
0,
SkIntToScalar(249),
@ -206,7 +204,8 @@ static void test_wacky_bitmapshader(skiatest::Reporter* reporter,
0.0078740157f,
SkIntToScalar(239),
0, 0, SK_Scalar1);
s->setLocalMatrix(matrix);
SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &matrix);
SkPaint paint;
paint.setShader(s)->unref();