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

hide savelayer's clipmask fields

Browse Source 
Bug: skia:9208
Change-Id: Ieff64b3132e7bf4a51ce9d70ea2f1bad492616da
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/223923
Reviewed-by: Florin Malita <fmalita@chromium.org>
Commit-Queue: Mike Reed <reed@google.com>
This commit is contained in:
Mike Reed 2020-05-30 16:02:14 -04:00 committed by Skia Commit-Bot
parent 94230f4b05
commit b42a327926
12 changed files with 51 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bench/ClipMaskBench.cpp
View File

@ -14,6 +14,7 @@
#include "include/core/SkSurface.h"
#include "tools/ToolUtils.h"
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
static void DrawMask(SkCanvas* canvas) {
ToolUtils::draw_checkerboard(canvas, SK_ColorTRANSPARENT, SK_ColorGREEN, 10);
}
@ -65,6 +66,7 @@ DEF_BENCH(return new ClipMaskBench("picture", [](int size) -> sk_sp<SkImage> {
nullptr, nullptr, SkImage::BitDepth::kU8,
SkColorSpace::MakeSRGB());
});)
#endif
/////////
#include "include/core/SkPath.h"

4
gm/backdrop_imagefilter_croprect.cpp
View File

@ -54,8 +54,8 @@ static void draw_backdrop_filter_gm(SkCanvas* canvas, float outsetX, float outse
if (i == 1) {
// Backdrop mode, so save a layer using the image filter as the backdrop to filter
// content on initialization.
canvas->saveLayer({nullptr, nullptr, imageFilter.get(), nullptr, nullptr,
SkCanvas::kInitWithPrevious_SaveLayerFlag});
canvas->saveLayer(SkCanvas::SaveLayerRec(nullptr, nullptr, imageFilter.get(),
SkCanvas::kInitWithPrevious_SaveLayerFlag));
}
// Restore the saved layer (either a main layer that was just drawn into and needs to be

2
gm/imagefilters.cpp
View File

@ -134,7 +134,7 @@ static void draw_set(SkCanvas* canvas, sk_sp<SkImageFilter> filters[], int count
canvas->save();
SkRRect rr = SkRRect::MakeRectXY(r.makeOffset(dx, dy), 20, 20);
canvas->clipRRect(rr, true);
canvas->saveLayer({ &rr.getBounds(), nullptr, filters[i].get(), nullptr, nullptr, 0 });
canvas->saveLayer(SkCanvas::SaveLayerRec(&rr.getBounds(), nullptr, filters[i].get(), 0));
canvas->drawColor(0x40FFFFFF);
canvas->restore();
canvas->restore();

10
gm/savelayer.cpp
View File

@ -50,7 +50,7 @@ static void save_layer_unclipped(SkCanvas* canvas,
SkPaint paint;
paint.setAlphaf(0.25f);
SkRect rect = SkRect::MakeLTRB(l, t, r, b);
canvas->saveLayer({ &rect, &paint, nullptr, nullptr, nullptr,
canvas->saveLayer({ &rect, &paint, nullptr,
(SkCanvas::SaveLayerFlags) SkCanvasPriv::kDontClipToLayer_SaveLayerFlag });
}
@ -108,8 +108,8 @@ DEF_SIMPLE_GM(picture_savelayer, canvas, 320, 640) {
canvas->translate(100 * i, 0);
auto flag = i ?
(SkCanvas::SaveLayerFlags) SkCanvasPriv::kDontClipToLayer_SaveLayerFlag : 0;
canvas->saveLayer({ &rect1, &paint1, nullptr, nullptr, nullptr, flag});
canvas->saveLayer({ &rect2, &paint2, nullptr, nullptr, nullptr, flag});
canvas->saveLayer(SkCanvas::SaveLayerRec(&rect1, &paint1, nullptr, flag));
canvas->saveLayer(SkCanvas::SaveLayerRec(&rect2, &paint2, nullptr, flag));
canvas->drawRect(rect3, paint3);
canvas->restore();
canvas->restore();
@ -134,6 +134,7 @@ DEF_SIMPLE_GM(savelayer_initfromprev, canvas, 256, 256) {
canvas->restore();
};
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
static void draw_mask(SkCanvas* canvas, int size) {
const SkScalar cx = size * SK_ScalarHalf,
cy = cx;
@ -243,6 +244,7 @@ DEF_SIMPLE_GM(savelayer_clipmask, canvas, 1200, 1200) {
}
}
}
#endif
DEF_SIMPLE_GM(savelayer_coverage, canvas, 500, 500) {
canvas->saveLayer(nullptr, nullptr);
@ -282,6 +284,7 @@ DEF_SIMPLE_GM(savelayer_coverage, canvas, 500, 500) {
canvas->restore();
}
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
DEF_SIMPLE_GM(savelayer_clipmask_maskfilter, canvas, 500, 500) {
// Offscreen surface for making the clip mask and mask filter images
auto surf = SkSurface::MakeRaster(SkImageInfo::MakeA8(100, 100));
@ -340,6 +343,7 @@ DEF_SIMPLE_GM(savelayer_clipmask_maskfilter, canvas, 500, 500) {
canvas->clear(SK_ColorWHITE);
canvas->restore();
}
#endif
static void draw_cell(SkCanvas* canvas, sk_sp<SkTextBlob> blob, SkColor c, SkScalar w, SkScalar h,
bool useDrawBehind) {

5
include/core/SkCanvas.h
View File

@ -684,6 +684,7 @@ public:
, fSaveLayerFlags(saveLayerFlags)
{}
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
/** Experimental. Not ready for general use.
Sets fBounds, fPaint, fBackdrop, fClipMask, fClipMatrix, and fSaveLayerFlags.
clipMatrix uses alpha channel of image, transformed by clipMatrix, to clip
@ -712,6 +713,7 @@ public:
, fClipMatrix(clipMatrix)
, fSaveLayerFlags(saveLayerFlags)
{}
#endif
/** hints at layer size limit */
const SkRect* fBounds = nullptr;
@ -727,12 +729,13 @@ public:
*/
const SkImageFilter* fBackdrop = nullptr;
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
/** clips layer with mask alpha */
const SkImage* fClipMask = nullptr;
/** transforms mask alpha used to clip */
const SkMatrix* fClipMatrix = nullptr;
#endif
/** preserves LCD text, creates with prior layer contents */
SaveLayerFlags fSaveLayerFlags = 0;
};

2
samplecode/SampleLayers.cpp
View File

@ -206,7 +206,7 @@ protected:
SkPaint paint;
paint.setAlpha(0xCC);
canvas->saveLayer({ &bounds, &paint, fFilter.get(), nullptr, nullptr, 0 });
canvas->saveLayer(SkCanvas::SaveLayerRec(&bounds, &paint, fFilter.get(), 0));
canvas->restore();
}

8
src/core/SkCanvas.cpp
View File

@ -1177,7 +1177,13 @@ void SkCanvas::internalSaveLayer(const SaveLayerRec& rec, SaveLayerStrategy stra
}
newDevice->setMarkerStack(fMarkerStack.get());
}
DeviceCM* layer = new DeviceCM(newDevice, paint, stashedMatrix, rec.fClipMask, rec.fClipMatrix);
DeviceCM* layer = new DeviceCM(newDevice, paint, stashedMatrix,
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
rec.fClipMask, rec.fClipMatrix
#else
nullptr, nullptr
#endif
);
// only have a "next" if this new layer doesn't affect the clip (rare)
layer->fNext = BoundsAffectsClip(saveLayerFlags) ? nullptr : fMCRec->fTopLayer;

9
src/core/SkPicturePlayback.cpp
View File

@ -601,7 +601,7 @@ void SkPicturePlayback::handleOp(SkReadBuffer* reader,
canvas->saveLayer(SkCanvas::SaveLayerRec(boundsPtr, paint, flags));
} break;
case SAVE_LAYER_SAVELAYERREC: {
SkCanvas::SaveLayerRec rec(nullptr, nullptr, nullptr, nullptr, nullptr, 0);
SkCanvas::SaveLayerRec rec(nullptr, nullptr, nullptr, 0);
SkMatrix clipMatrix;
const uint32_t flatFlags = reader->readInt();
SkRect bounds;
@ -621,11 +621,16 @@ void SkPicturePlayback::handleOp(SkReadBuffer* reader,
rec.fSaveLayerFlags = reader->readInt();
}
if (flatFlags & SAVELAYERREC_HAS_CLIPMASK) {
rec.fClipMask = fPictureData->getImage(reader);
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
rec.fClipMask =
#endif
fPictureData->getImage(reader);
}
if (flatFlags & SAVELAYERREC_HAS_CLIPMATRIX) {
reader->readMatrix(&clipMatrix);
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
rec.fClipMatrix = &clipMatrix;
#endif
}
BREAK_ON_READ_ERROR(reader);

4
src/core/SkPictureRecord.cpp
View File

@ -129,6 +129,7 @@ void SkPictureRecord::recordSaveLayer(const SaveLayerRec& rec) {
flatFlags |= SAVELAYERREC_HAS_FLAGS;
size += sizeof(uint32_t);
}
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
if (rec.fClipMask) {
flatFlags |= SAVELAYERREC_HAS_CLIPMASK;
size += sizeof(uint32_t); // clip image index
@ -137,6 +138,7 @@ void SkPictureRecord::recordSaveLayer(const SaveLayerRec& rec) {
flatFlags |= SAVELAYERREC_HAS_CLIPMATRIX;
size += SkMatrixPriv::WriteToMemory(*rec.fClipMatrix, nullptr);
}
#endif
const size_t initialOffset = this->addDraw(SAVE_LAYER_SAVELAYERREC, &size);
this->addInt(flatFlags);
@ -155,12 +157,14 @@ void SkPictureRecord::recordSaveLayer(const SaveLayerRec& rec) {
if (flatFlags & SAVELAYERREC_HAS_FLAGS) {
this->addInt(rec.fSaveLayerFlags);
}
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
if (flatFlags & SAVELAYERREC_HAS_CLIPMASK) {
this->addImage(rec.fClipMask);
}
if (flatFlags & SAVELAYERREC_HAS_CLIPMATRIX) {
this->addMatrix(*rec.fClipMatrix);
}
#endif
this->validate(initialOffset, size);
}

7
src/core/SkRecordDraw.cpp
View File

@ -78,12 +78,19 @@ template <> void Draw::draw(const NoOp&) {}
DRAW(Flush, flush());
DRAW(Restore, restore());
DRAW(Save, save());
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
DRAW(SaveLayer, saveLayer(SkCanvas::SaveLayerRec(r.bounds,
r.paint,
r.backdrop.get(),
r.clipMask.get(),
r.clipMatrix,
r.saveLayerFlags)));
#else
DRAW(SaveLayer, saveLayer(SkCanvas::SaveLayerRec(r.bounds,
r.paint,
r.backdrop.get(),
r.saveLayerFlags)));
#endif
template <> void Draw::draw(const SaveBehind& r) {
SkCanvasPriv::SaveBehind(fCanvas, r.subset);

4
src/core/SkRecorder.cpp
View File

@ -316,8 +316,12 @@ SkCanvas::SaveLayerStrategy SkRecorder::getSaveLayerStrategy(const SaveLayerRec&
this->append<SkRecords::SaveLayer>(this->copy(rec.fBounds)
, this->copy(rec.fPaint)
, sk_ref_sp(rec.fBackdrop)
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
, sk_ref_sp(rec.fClipMask)
, this->copy(rec.fClipMatrix)
#else
, nullptr, nullptr
#endif
, rec.fSaveLayerFlags);
return SkCanvas::kNoLayer_SaveLayerStrategy;
}

10
tests/RecordOptsTest.cpp
View File

@ -189,12 +189,13 @@ DEF_TEST(RecordOpts_NoopSaveLayerDrawRestore, r) {
// saveLayer w/ backdrop should NOT go away
sk_sp<SkImageFilter> filter(SkImageFilters::Blur(3, 3, nullptr));
recorder.saveLayer({ nullptr, nullptr, filter.get(), nullptr, nullptr, 0});
recorder.saveLayer({ nullptr, nullptr, filter.get(), 0});
recorder.drawRect(draw, opaqueDrawPaint);
recorder.restore();
assert_savelayer_draw_restore(r, &record, 18, false);
// saveLayer w/ clip mask should also NOT go away
#ifdef SK_SUPPORT_LEGACY_LAYERCLIPMASK
{
sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(10, 10));
recorder.saveLayer({ nullptr, nullptr, nullptr, surface->makeImageSnapshot().get(),
@ -203,6 +204,7 @@ DEF_TEST(RecordOpts_NoopSaveLayerDrawRestore, r) {
recorder.restore();
assert_savelayer_draw_restore(r, &record, 21, false);
}
#endif
}
#endif
@ -274,12 +276,10 @@ DEF_TEST(RecordOpts_MergeSvgOpacityAndFilterLayers, r) {
for (size_t m = 0; m < SK_ARRAY_COUNT(secondPaints); ++m) {
bool innerNoOped = !secondBounds[k] && !secondPaints[m] && !innerF;
recorder.saveLayer({firstBounds[i], firstPaints[j], outerF,
nullptr, nullptr, 0});
recorder.saveLayer({firstBounds[i], firstPaints[j], outerF, 0});
recorder.save();
recorder.clipRect(clip);
recorder.saveLayer({secondBounds[k], secondPaints[m], innerF,
nullptr, nullptr, 0});
recorder.saveLayer({secondBounds[k], secondPaints[m], innerF, 0});
recorder.restore();
recorder.restore();
recorder.restore();