SkScan Class Reference

#include <SkScan.h>

Public Types
typedef void(*	HairRgnProc) (const SkPoint[], int count, const SkRegion *, SkBlitter *)
typedef void(*	HairRCProc) (const SkPoint[], int count, const SkRasterClip &, SkBlitter *)

Static Public Member Functions
static void	FillPath (const SkPath &, const SkIRect &, SkBlitter *)
static bool	PathRequiresTiling (const SkIRect &bounds)
static void	FillIRect (const SkIRect &, const SkRasterClip &, SkBlitter *)
static void	FillXRect (const SkXRect &, const SkRasterClip &, SkBlitter *)
static void	FillRect (const SkRect &, const SkRasterClip &, SkBlitter *)
static void	AntiFillRect (const SkRect &, const SkRasterClip &, SkBlitter *)
static void	AntiFillXRect (const SkXRect &, const SkRasterClip &, SkBlitter *)
static void	FillPath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	AntiFillPath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	FrameRect (const SkRect &, const SkPoint &strokeSize, const SkRasterClip &, SkBlitter *)
static void	AntiFrameRect (const SkRect &, const SkPoint &strokeSize, const SkRasterClip &, SkBlitter *)
static void	FillTriangle (const SkPoint pts[], const SkRasterClip &, SkBlitter *)
static void	HairLine (const SkPoint[], int count, const SkRasterClip &, SkBlitter *)
static void	AntiHairLine (const SkPoint[], int count, const SkRasterClip &, SkBlitter *)
static void	HairRect (const SkRect &, const SkRasterClip &, SkBlitter *)
static void	AntiHairRect (const SkRect &, const SkRasterClip &, SkBlitter *)
static void	HairPath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	AntiHairPath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	HairSquarePath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	AntiHairSquarePath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	HairRoundPath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	AntiHairRoundPath (const SkPath &, const SkRasterClip &, SkBlitter *)
static void	FillPath (const SkPath &, const SkRegion &clip, SkBlitter *)

Friends
class	SkAAClip
class	SkRegion

Detailed Description

Definition at line 26 of file SkScan.h.

Member Typedef Documentation

HairRCProc

typedef void(* SkScan::HairRCProc) (const SkPoint[], int count, const SkRasterClip &, SkBlitter *)

Definition at line 35 of file SkScan.h.

HairRgnProc

typedef void(* SkScan::HairRgnProc) (const SkPoint[], int count, const SkRegion *, SkBlitter *)

Definition at line 34 of file SkScan.h.

Member Function Documentation

AntiFillPath()

void SkScan::AntiFillPath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 155 of file SkScan_AntiPath.cpp.

                                                                                          {
    if (clip.isEmpty() || !path.isFinite()) {
        return;
    }
 
    if (clip.isBW()) {
        AntiFillPath(path, clip.bwRgn(), blitter, false);
    } else {
        SkRegion        tmp;
        SkAAClipBlitter aaBlitter;
 
        tmp.setRect(clip.getBounds());
        aaBlitter.init(blitter, &clip.aaRgn());
        AntiFillPath(path, tmp, &aaBlitter, true); // SkAAClipBlitter can blitMask, why forceRLE?
    }
}

AntiFillRect()

void SkScan::AntiFillRect ( const SkRect &  r, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 822 of file SkScan_Antihair.cpp.

                                              {
    if (clip.isBW()) {
        AntiFillRect(r, &clip.bwRgn(), blitter);
    } else {
        SkAAClipBlitterWrapper wrap(clip, blitter);
        AntiFillRect(r, &wrap.getRgn(), wrap.getBlitter());
    }
}

AntiFillXRect()

void SkScan::AntiFillXRect ( const SkXRect &  xr, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 758 of file SkScan_Antihair.cpp.

                                               {
    if (clip.isBW()) {
        AntiFillXRect(xr, &clip.bwRgn(), blitter);
    } else {
        SkIRect outerBounds;
        XRect_roundOut(xr, &outerBounds);
 
        if (clip.quickContains(outerBounds)) {
            AntiFillXRect(xr, nullptr, blitter);
        } else {
            SkAAClipBlitterWrapper wrapper(clip, blitter);
            AntiFillXRect(xr, &wrapper.getRgn(), wrapper.getBlitter());
        }
    }
}

AntiFrameRect()

void SkScan::AntiFrameRect ( const SkRect &  r, const SkPoint &  strokeSize, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 1016 of file SkScan_Antihair.cpp.

                                                                         {
    if (clip.isBW()) {
        AntiFrameRect(r, strokeSize, &clip.bwRgn(), blitter);
    } else {
        SkAAClipBlitterWrapper wrap(clip, blitter);
        AntiFrameRect(r, strokeSize, &wrap.getRgn(), wrap.getBlitter());
    }
}

AntiHairLine()

void SkScan::AntiHairLine ( const SkPoint  pts[], int  count, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 738 of file SkScan_Hairline.cpp.

                                              {
    if (clip.isBW()) {
        AntiHairLineRgn(pts, count, &clip.bwRgn(), blitter);
    } else {
        const SkRegion* clipRgn = nullptr;
 
        SkRect r;
        r.setBounds(pts, count);
 
        SkAAClipBlitterWrapper wrap;
        if (!clip.quickContains(r.roundOut().makeOutset(1, 1))) {
            wrap.init(clip, blitter);
            blitter = wrap.getBlitter();
            clipRgn = &wrap.getRgn();
        }
        AntiHairLineRgn(pts, count, clipRgn, blitter);
    }
}

AntiHairPath()

void SkScan::AntiHairPath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 661 of file SkScan_Hairline.cpp.

                                                                                          {
    hair_path<SkPaint::kButt_Cap>(path, clip, blitter, SkScan::AntiHairLineRgn);
}

AntiHairRect()

void SkScan::AntiHairRect ( const SkRect &  rect, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 621 of file SkScan_Antihair.cpp.

                                              {
    SkPoint pts[5];
 
    pts[0].set(rect.fLeft, rect.fTop);
    pts[1].set(rect.fRight, rect.fTop);
    pts[2].set(rect.fRight, rect.fBottom);
    pts[3].set(rect.fLeft, rect.fBottom);
    pts[4] = pts[0];
    SkScan::AntiHairLine(pts, 5, clip, blitter);
}

AntiHairRoundPath()

void SkScan::AntiHairRoundPath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 677 of file SkScan_Hairline.cpp.

                                                                                               {
    hair_path<SkPaint::kRound_Cap>(path, clip, blitter, SkScan::AntiHairLineRgn);
}

AntiHairSquarePath()

void SkScan::AntiHairSquarePath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 669 of file SkScan_Hairline.cpp.

                                                                                                {
    hair_path<SkPaint::kSquare_Cap>(path, clip, blitter, SkScan::AntiHairLineRgn);
}

FillIRect()

void SkScan::FillIRect ( const SkIRect &  r, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 65 of file SkScan.cpp.

                                           {
    if (clip.isEmpty() || r.isEmpty()) {
        return;
    }
 
    if (clip.isBW()) {
        FillIRect(r, &clip.bwRgn(), blitter);
        return;
    }
 
    SkAAClipBlitterWrapper wrapper(clip, blitter);
    FillIRect(r, &wrapper.getRgn(), wrapper.getBlitter());
}

FillPath() [1/3]

void SkScan::FillPath ( const SkPath &  path, const SkIRect &  ir, SkBlitter *  blitter  )

static

Definition at line 682 of file SkScan_Path.cpp.

                                          {
    SkRegion rgn(ir);
    FillPath(path, rgn, blitter);
}

FillPath() [2/3]

void SkScan::FillPath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 138 of file SkScan_AntiPath.cpp.

                                                                                      {
    if (clip.isEmpty() || !path.isFinite()) {
        return;
    }
 
    if (clip.isBW()) {
        FillPath(path, clip.bwRgn(), blitter);
    } else {
        SkRegion        tmp;
        SkAAClipBlitter aaBlitter;
 
        tmp.setRect(clip.getBounds());
        aaBlitter.init(blitter, &clip.aaRgn());
        SkScan::FillPath(path, tmp, &aaBlitter);
    }
}

FillPath() [3/3]

void SkScan::FillPath ( const SkPath &  path, const SkRegion &  clip, SkBlitter *  blitter  )

static

Definition at line 625 of file SkScan_Path.cpp.

                                          {
    if (origClip.isEmpty()) {
        return;
    }
 
    // Our edges are fixed-point, and don't like the bounds of the clip to
    // exceed that. Here we trim the clip just so we don't overflow later on
    const SkRegion* clipPtr = &origClip;
    SkRegion finiteClip;
    if (clip_to_limit(origClip, &finiteClip)) {
        if (finiteClip.isEmpty()) {
            return;
        }
        clipPtr = &finiteClip;
    }
    // don't reference "origClip" any more, just use clipPtr
 
 
    SkRect bounds = path.getBounds();
    bool irPreClipped = false;
    if (!SkRectPriv::MakeLargeS32().contains(bounds)) {
        if (!bounds.intersect(SkRectPriv::MakeLargeS32())) {
            bounds.setEmpty();
        }
        irPreClipped = true;
    }
 
    SkIRect ir = conservative_round_to_int(bounds);
    if (ir.isEmpty()) {
        if (path.isInverseFillType()) {
            blitter->blitRegion(*clipPtr);
        }
        return;
    }
 
    SkScanClipper clipper(blitter, clipPtr, ir, path.isInverseFillType(), irPreClipped);
 
    blitter = clipper.getBlitter();
    if (blitter) {
        // we have to keep our calls to blitter in sorted order, so we
        // must blit the above section first, then the middle, then the bottom.
        if (path.isInverseFillType()) {
            sk_blit_above(blitter, ir, *clipPtr);
        }
        SkASSERT(clipper.getClipRect() == nullptr ||
                *clipper.getClipRect() == clipPtr->getBounds());
        sk_fill_path(path, clipPtr->getBounds(), blitter, ir.fTop, ir.fBottom,
                     0, clipper.getClipRect() == nullptr);
        if (path.isInverseFillType()) {
            sk_blit_below(blitter, ir, *clipPtr);
        }
    } else {
        // what does it mean to not have a blitter if path.isInverseFillType???
    }
}

FillRect()

void SkScan::FillRect ( const SkRect &  r, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 95 of file SkScan.cpp.

                                          {
    if (clip.isEmpty() || r.isEmpty()) {
        return;
    }
 
    if (clip.isBW()) {
        FillRect(r, &clip.bwRgn(), blitter);
        return;
    }
 
    SkAAClipBlitterWrapper wrapper(clip, blitter);
    FillRect(r, &wrapper.getRgn(), wrapper.getBlitter());
}

FillTriangle()

void SkScan::FillTriangle ( const SkPoint  pts[], const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 754 of file SkScan_Path.cpp.

                                              {
    if (clip.isEmpty()) {
        return;
    }
 
    SkRect  r;
    r.setBounds(pts, 3);
    // If r is too large (larger than can easily fit in SkFixed) then we need perform geometric
    // clipping. This is a bit of work, so we just call the general FillPath() to handle it.
    // Use FixedMax/2 as the limit so we can subtract two edges and still store that in Fixed.
    const SkScalar limit = SK_MaxS16 >> 1;
    if (!SkRect::MakeLTRB(-limit, -limit, limit, limit).contains(r)) {
        SkPath path;
        path.addPoly(pts, 3, false);
        FillPath(path, clip, blitter);
        return;
    }
 
    SkIRect ir = conservative_round_to_int(r);
    if (ir.isEmpty() || !SkIRect::Intersects(ir, clip.getBounds())) {
        return;
    }
 
    SkAAClipBlitterWrapper wrap;
    const SkRegion* clipRgn;
    if (clip.isBW()) {
        clipRgn = &clip.bwRgn();
    } else {
        wrap.init(clip, blitter);
        clipRgn = &wrap.getRgn();
        blitter = wrap.getBlitter();
    }
 
    SkScanClipper clipper(blitter, clipRgn, ir);
    blitter = clipper.getBlitter();
    if (blitter) {
        sk_fill_triangle(pts, clipper.getClipRect(), blitter, ir);
    }
}

FillXRect()

void SkScan::FillXRect ( const SkXRect &  xr, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 80 of file SkScan.cpp.

                                           {
    if (clip.isEmpty() || xr.isEmpty()) {
        return;
    }
 
    if (clip.isBW()) {
        FillXRect(xr, &clip.bwRgn(), blitter);
        return;
    }
 
    SkAAClipBlitterWrapper wrapper(clip, blitter);
    FillXRect(xr, &wrapper.getRgn(), wrapper.getBlitter());
}

FrameRect()

void SkScan::FrameRect ( const SkRect &  r, const SkPoint &  strokeSize, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 683 of file SkScan_Hairline.cpp.

                                                                     {
    SkASSERT(strokeSize.fX >= 0 && strokeSize.fY >= 0);
 
    if (strokeSize.fX < 0 || strokeSize.fY < 0) {
        return;
    }
 
    const SkScalar dx = strokeSize.fX;
    const SkScalar dy = strokeSize.fY;
    SkScalar rx = SkScalarHalf(dx);
    SkScalar ry = SkScalarHalf(dy);
    SkRect   outer, tmp;
 
    outer.setLTRB(r.fLeft - rx, r.fTop - ry, r.fRight + rx, r.fBottom + ry);
 
    if (r.width() <= dx || r.height() <= dy) {
        SkScan::FillRect(outer, clip, blitter);
        return;
    }
 
    tmp.setLTRB(outer.fLeft, outer.fTop, outer.fRight, outer.fTop + dy);
    SkScan::FillRect(tmp, clip, blitter);
    tmp.fTop = outer.fBottom - dy;
    tmp.fBottom = outer.fBottom;
    SkScan::FillRect(tmp, clip, blitter);
 
    tmp.setLTRB(outer.fLeft, outer.fTop + dy, outer.fLeft + dx, outer.fBottom - dy);
    SkScan::FillRect(tmp, clip, blitter);
    tmp.fLeft = outer.fRight - dx;
    tmp.fRight = outer.fRight;
    SkScan::FillRect(tmp, clip, blitter);
}

HairLine()

void SkScan::HairLine ( const SkPoint  pts[], int  count, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 717 of file SkScan_Hairline.cpp.

                                          {
    if (clip.isBW()) {
        HairLineRgn(pts, count, &clip.bwRgn(), blitter);
    } else {
        const SkRegion* clipRgn = nullptr;
 
        SkRect r;
        r.setBounds(pts, count);
        r.outset(SK_ScalarHalf, SK_ScalarHalf);
 
        SkAAClipBlitterWrapper wrap;
        if (!clip.quickContains(r.roundOut())) {
            wrap.init(clip, blitter);
            blitter = wrap.getBlitter();
            clipRgn = &wrap.getRgn();
        }
        HairLineRgn(pts, count, clipRgn, blitter);
    }
}

HairPath()

void SkScan::HairPath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 657 of file SkScan_Hairline.cpp.

                                                                                      {
    hair_path<SkPaint::kButt_Cap>(path, clip, blitter, SkScan::HairLineRgn);
}

HairRect()

void SkScan::HairRect ( const SkRect &  rect, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 177 of file SkScan_Hairline.cpp.

                                                                                      {
    SkAAClipBlitterWrapper wrapper;
    SkBlitterClipper clipper;
    // Create the enclosing bounds of the hairrect. i.e. we will stroke the interior of r.
    SkIRect r = SkIRect::MakeLTRB(SkScalarFloorToInt(rect.fLeft),
                                  SkScalarFloorToInt(rect.fTop),
                                  SkScalarFloorToInt(rect.fRight + 1),
                                  SkScalarFloorToInt(rect.fBottom + 1));
 
    // Note: r might be crazy big, if rect was huge, possibly getting pinned to max/min s32.
    // We need to trim it back to something reasonable before we can query its width etc.
    // since r.fRight - r.fLeft might wrap around to negative even if fRight > fLeft.
    //
    // We outset the clip bounds by 1 before intersecting, since r is being stroked and not filled
    // so we don't want to pin an edge of it to the clip. The intersect's job is mostly to just
    // get the actual edge values into a reasonable range (e.g. so width() can't overflow).
    if (!r.intersect(clip.getBounds().makeOutset(1, 1))) {
        return;
    }
 
    if (clip.quickReject(r)) {
        return;
    }
    if (!clip.quickContains(r)) {
        const SkRegion* clipRgn;
        if (clip.isBW()) {
            clipRgn = &clip.bwRgn();
        } else {
            wrapper.init(clip, blitter);
            clipRgn = &wrapper.getRgn();
            blitter = wrapper.getBlitter();
        }
        blitter = clipper.apply(blitter, clipRgn);
    }
 
    int width = r.width();
    int height = r.height();
 
    if ((width | height) == 0) {
        return;
    }
    if (width <= 2 || height <= 2) {
        blitter->blitRect(r.fLeft, r.fTop, width, height);
        return;
    }
    // if we get here, we know we have 4 segments to draw
    blitter->blitH(r.fLeft, r.fTop, width);                     // top
    blitter->blitRect(r.fLeft, r.fTop + 1, 1, height - 2);      // left
    blitter->blitRect(r.fRight - 1, r.fTop + 1, 1, height - 2); // right
    blitter->blitH(r.fLeft, r.fBottom - 1, width);              // bottom
}

HairRoundPath()

void SkScan::HairRoundPath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 673 of file SkScan_Hairline.cpp.

                                                                                           {
    hair_path<SkPaint::kRound_Cap>(path, clip, blitter, SkScan::HairLineRgn);
}

HairSquarePath()

void SkScan::HairSquarePath ( const SkPath &  path, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 665 of file SkScan_Hairline.cpp.

                                                                                            {
    hair_path<SkPaint::kSquare_Cap>(path, clip, blitter, SkScan::HairLineRgn);
}

PathRequiresTiling()

bool SkScan::PathRequiresTiling ( const SkIRect &  bounds )

static

Definition at line 688 of file SkScan_Path.cpp.

                                                     {
    SkRegion out;  // ignored
    return clip_to_limit(SkRegion(bounds), &out);
}

Friends And Related Function Documentation

SkAAClip

friend class SkAAClip

friend

Definition at line 75 of file SkScan.h.

SkRegion

friend class SkRegion

friend

Definition at line 76 of file SkScan.h.

---

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

• third_party/skia/src/core/SkScan.h
• third_party/skia/src/core/SkScan.cpp
• third_party/skia/src/core/SkScan_AAAPath.cpp
• third_party/skia/src/core/SkScan_Antihair.cpp
• third_party/skia/src/core/SkScan_AntiPath.cpp
• third_party/skia/src/core/SkScan_Hairline.cpp
• third_party/skia/src/core/SkScan_Path.cpp