SkCanvasPriv Class Reference

#include <SkCanvasPriv.h>

Static Public Member Functions
static bool	ReadLattice (SkReadBuffer &, SkCanvas::Lattice *)
static void	WriteLattice (SkWriteBuffer &, const SkCanvas::Lattice &)
static size_t	WriteLattice (void *storage, const SkCanvas::Lattice &)
static int	SaveBehind (SkCanvas *canvas, const SkRect *subset)
static void	DrawBehind (SkCanvas *canvas, const SkPaint &paint)
static void	ResetClip (SkCanvas *canvas)
static SkDevice *	TopDevice (const SkCanvas *canvas)
static void	GetDstClipAndMatrixCounts (const SkCanvas::ImageSetEntry set[], int count, int *totalDstClipCount, int *totalMatrixCount)
static SkCanvas::SaveLayerRec	ScaledBackdropLayer (const SkRect *bounds, const SkPaint *paint, const SkImageFilter *backdrop, SkScalar backdropScale, SkCanvas::SaveLayerFlags saveLayerFlags, SkCanvas::FilterSpan filters={})
static SkScalar	GetBackdropScaleFactor (const SkCanvas::SaveLayerRec &rec)
static void	SetBackdropScaleFactor (SkCanvas::SaveLayerRec *rec, SkScalar scale)
static bool	ImageToColorFilter (SkPaint *)

Detailed Description

Definition at line 42 of file SkCanvasPriv.h.

Member Function Documentation

DrawBehind()

static void SkCanvasPriv::DrawBehind ( SkCanvas *  canvas, const SkPaint &  paint  )

inlinestatic

Definition at line 56 of file SkCanvasPriv.h.

                                                                   {
        canvas->drawClippedToSaveBehind(paint);
    }

GetBackdropScaleFactor()

static SkScalar SkCanvasPriv::GetBackdropScaleFactor ( const SkCanvas::SaveLayerRec &  rec )

inlinestatic

Definition at line 85 of file SkCanvasPriv.h.

                                                                            {
        return rec.fExperimentalBackdropScale;
    }

GetDstClipAndMatrixCounts()

void SkCanvasPriv::GetDstClipAndMatrixCounts ( const SkCanvas::ImageSetEntry  set[], int  count, int *  totalDstClipCount, int *  totalMatrixCount  )

static

Definition at line 103 of file SkCanvasPriv.cpp.

                                                                                            {
    int dstClipCount = 0;
    int maxMatrixIndex = -1;
    for (int i = 0; i < count; ++i) {
        dstClipCount += 4 * set[i].fHasClip;
        if (set[i].fMatrixIndex > maxMatrixIndex) {
            maxMatrixIndex = set[i].fMatrixIndex;
        }
    }
 
    *totalDstClipCount = dstClipCount;
    *totalMatrixCount = maxMatrixIndex + 1;
}

ImageToColorFilter()

bool SkCanvasPriv::ImageToColorFilter ( SkPaint *  paint )

static

Definition at line 121 of file SkCanvasPriv.cpp.

                                                    {
    SkASSERT(SkToBool(paint) && paint->getImageFilter());
 
    // An image filter logically runs after any mask filter and the src-over blending against the
    // layer's transparent black initial content. Moving the image filter (as a color filter) into
    // the color filter slot causes it to run before the mask filter or blending.
    //
    // Src-over blending against transparent black is a no-op, so skipping the layer and drawing the
    // output of the color filter-image filter with the original blender is valid.
    //
    // If there's also a mask filter on the paint, it will operate on an alpha-only layer that's
    // then shaded with the paint's effects. Moving the CF-IF into the paint's color filter slot
    // will mean that the CF-IF operates on the output of the original CF *before* it's combined
    // with the coverage value. Under normal circumstances the CF-IF evaluates the color after
    // coverage has been multiplied into the alpha channel.
    //
    // Some color filters may behave the same, e.g. cf(color)*coverage == cf(color*coverage), but
    // that's hard to detect so we disable the optimization when both image filters and mask filters
    // are present.
    if (paint->getMaskFilter()) {
        return false;
    }
 
    SkColorFilter* imgCFPtr;
    if (!paint->getImageFilter()->asAColorFilter(&imgCFPtr)) {
        return false;
    }
    sk_sp<SkColorFilter> imgCF(imgCFPtr);
 
    SkColorFilter* paintCF = paint->getColorFilter();
    if (paintCF) {
        // The paint has both a colorfilter(paintCF) and an imagefilter-that-is-a-colorfilter(imgCF)
        // and we need to combine them into a single colorfilter.
        imgCF = imgCF->makeComposed(sk_ref_sp(paintCF));
    }
 
    paint->setColorFilter(std::move(imgCF));
    paint->setImageFilter(nullptr);
    return true;
}

ReadLattice()

bool SkCanvasPriv::ReadLattice ( SkReadBuffer &  buffer, SkCanvas::Lattice *  lattice  )

static

Definition at line 56 of file SkCanvasPriv.cpp.

                                                                             {
    lattice->fXCount = buffer.readInt();
    lattice->fXDivs = buffer.skipT<int32_t>(lattice->fXCount);
    lattice->fYCount = buffer.readInt();
    lattice->fYDivs = buffer.skipT<int32_t>(lattice->fYCount);
    int flagCount = buffer.readInt();
    lattice->fRectTypes = nullptr;
    lattice->fColors = nullptr;
    if (flagCount) {
        lattice->fRectTypes = buffer.skipT<SkCanvas::Lattice::RectType>(flagCount);
        lattice->fColors = buffer.skipT<SkColor>(flagCount);
    }
    lattice->fBounds = buffer.skipT<SkIRect>();
    return buffer.isValid();
}

ResetClip()

static void SkCanvasPriv::ResetClip ( SkCanvas *  canvas )

inlinestatic

Definition at line 61 of file SkCanvasPriv.h.

                                            {
        canvas->internal_private_resetClip();
    }

SaveBehind()

static int SkCanvasPriv::SaveBehind ( SkCanvas *  canvas, const SkRect *  subset  )

inlinestatic

Definition at line 53 of file SkCanvasPriv.h.

                                                                  {
        return canvas->only_axis_aligned_saveBehind(subset);
    }

ScaledBackdropLayer()

static SkCanvas::SaveLayerRec SkCanvasPriv::ScaledBackdropLayer ( const SkRect *  bounds, const SkPaint *  paint, const SkImageFilter *  backdrop, SkScalar  backdropScale, SkCanvas::SaveLayerFlags  saveLayerFlags, SkCanvas::FilterSpan  filters = {}  )

inlinestatic

Definition at line 75 of file SkCanvasPriv.h.

                                                                                   {}) {
        return SkCanvas::SaveLayerRec(
                bounds, paint, backdrop, nullptr, backdropScale, saveLayerFlags, filters);
    }

SetBackdropScaleFactor()

static void SkCanvasPriv::SetBackdropScaleFactor ( SkCanvas::SaveLayerRec *  rec, SkScalar  scale  )

inlinestatic

Definition at line 89 of file SkCanvasPriv.h.

                                                                                  {
        rec->fExperimentalBackdropScale = scale;
    }

TopDevice()

static SkDevice * SkCanvasPriv::TopDevice ( const SkCanvas *  canvas )

inlinestatic

Definition at line 65 of file SkCanvasPriv.h.

                                                       {
        return canvas->topDevice();
    }

WriteLattice() [1/2]

void SkCanvasPriv::WriteLattice ( SkWriteBuffer &  buffer, const SkCanvas::Lattice &  lattice  )

static

Definition at line 96 of file SkCanvasPriv.cpp.

                                                                                     {
    const size_t size = WriteLattice(nullptr, lattice);
    SkAutoSMalloc<1024> storage(size);
    WriteLattice(storage.get(), lattice);
    buffer.writePad32(storage.get(), size);
}

WriteLattice() [2/2]

size_t SkCanvasPriv::WriteLattice ( void *  storage, const SkCanvas::Lattice &  lattice  )

static

Definition at line 72 of file SkCanvasPriv.cpp.

                                                                              {
    int flagCount = lattice.fRectTypes ? (lattice.fXCount + 1) * (lattice.fYCount + 1) : 0;
 
    const size_t size = (1 + lattice.fXCount + 1 + lattice.fYCount + 1) * sizeof(int32_t) +
                        SkAlign4(flagCount * sizeof(SkCanvas::Lattice::RectType)) +
                        SkAlign4(flagCount * sizeof(SkColor)) +
                        sizeof(SkIRect);
 
    if (buffer) {
        SkWriter32 writer(buffer, size);
        writer.write32(lattice.fXCount);
        writer.write(lattice.fXDivs, lattice.fXCount * sizeof(uint32_t));
        writer.write32(lattice.fYCount);
        writer.write(lattice.fYDivs, lattice.fYCount * sizeof(uint32_t));
        writer.write32(flagCount);
        writer.writePad(lattice.fRectTypes, flagCount * sizeof(uint8_t));
        writer.write(lattice.fColors, flagCount * sizeof(SkColor));
        SkASSERT(lattice.fBounds);
        writer.write(lattice.fBounds, sizeof(SkIRect));
        SkASSERT(writer.bytesWritten() == size);
    }
    return size;
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkCanvasPriv.h
• third_party/skia/src/core/SkCanvasPriv.cpp