SkScanPriv.h File Reference

#include "include/core/SkPath.h"
#include "src/core/SkBlitter.h"
#include "src/core/SkScan.h"

Go to the source code of this file.

Classes
class	SkScanClipper

Macros
#define	SK_SUPERSAMPLE_SHIFT   2

Functions
void	sk_fill_path (const SkPath &path, const SkIRect &clipRect, SkBlitter *blitter, int start_y, int stop_y, int shiftEdgesUp, bool pathContainedInClip)
void	sk_blit_above (SkBlitter *, const SkIRect &avoid, const SkRegion &clip)
void	sk_blit_below (SkBlitter *, const SkIRect &avoid, const SkRegion &clip)
template<class EdgeType >
static void	remove_edge (EdgeType *edge)
template<class EdgeType >
static void	insert_edge_after (EdgeType *edge, EdgeType *afterMe)
template<class EdgeType >
void	backward_insert_edge_based_on_x (EdgeType *edge)
template<class EdgeType >
EdgeType *	backward_insert_start (EdgeType *prev, SkFixed x)

Macro Definition Documentation

SK_SUPERSAMPLE_SHIFT

#define SK_SUPERSAMPLE_SHIFT   2

Definition at line 16 of file SkScanPriv.h.

Function Documentation

backward_insert_edge_based_on_x()

template<class EdgeType >

void backward_insert_edge_based_on_x

(

EdgeType *

edge

)

Definition at line 59 of file SkScanPriv.h.

                                                     {
    SkFixed x = edge->fX;
    EdgeType* prev = edge->fPrev;
    while (prev->fPrev && prev->fX > x) {
        prev = prev->fPrev;
    }
    if (prev->fNext != edge) {
        remove_edge(edge);
        insert_edge_after(edge, prev);
    }
}

backward_insert_start()

template<class EdgeType >

EdgeType * backward_insert_start	(	EdgeType *	prev,
		SkFixed	x
	)

Definition at line 76 of file SkScanPriv.h.

                                                           {
    while (prev->fPrev && prev->fX > x) {
        prev = prev->fPrev;
    }
    return prev;
}

insert_edge_after()

template<class EdgeType >

static void insert_edge_after ( EdgeType *  edge, EdgeType *  afterMe  )

inlinestatic

Definition at line 51 of file SkScanPriv.h.

                                                                        {
    edge->fPrev = afterMe;
    edge->fNext = afterMe->fNext;
    afterMe->fNext->fPrev = edge;
    afterMe->fNext = edge;
}

remove_edge()

template<class EdgeType >

static void remove_edge ( EdgeType *  edge )

inlinestatic

Definition at line 45 of file SkScanPriv.h.

                                               {
    edge->fPrev->fNext = edge->fNext;
    edge->fNext->fPrev = edge->fPrev;
}

sk_blit_above()

void sk_blit_above	(	SkBlitter *	blitter,
		const SkIRect &	avoid,
		const SkRegion &	clip
	)

Definition at line 487 of file SkScan_Path.cpp.

                                                                                {
    const SkIRect& cr = clip.getBounds();
    SkIRect tmp;
 
    tmp.fLeft = cr.fLeft;
    tmp.fRight = cr.fRight;
    tmp.fTop = cr.fTop;
    tmp.fBottom = ir.fTop;
    if (!tmp.isEmpty()) {
        blitter->blitRectRegion(tmp, clip);
    }
}

sk_blit_below()

void sk_blit_below	(	SkBlitter *	blitter,
		const SkIRect &	avoid,
		const SkRegion &	clip
	)

Definition at line 500 of file SkScan_Path.cpp.

                                                                                {
    const SkIRect& cr = clip.getBounds();
    SkIRect tmp;
 
    tmp.fLeft = cr.fLeft;
    tmp.fRight = cr.fRight;
    tmp.fTop = ir.fBottom;
    tmp.fBottom = cr.fBottom;
    if (!tmp.isEmpty()) {
        blitter->blitRectRegion(tmp, clip);
    }
}

sk_fill_path()

void sk_fill_path	(	const SkPath &	path,
		const SkIRect &	clipRect,
		SkBlitter *	blitter,
		int	start_y,
		int	stop_y,
		int	shiftEdgesUp,
		bool	pathContainedInClip
	)

Definition at line 404 of file SkScan_Path.cpp.

                                                                                       {
    SkASSERT(blitter);
 
    SkIRect shiftedClip = clipRect;
    shiftedClip.fLeft = SkLeftShift(shiftedClip.fLeft, shiftEdgesUp);
    shiftedClip.fRight = SkLeftShift(shiftedClip.fRight, shiftEdgesUp);
    shiftedClip.fTop = SkLeftShift(shiftedClip.fTop, shiftEdgesUp);
    shiftedClip.fBottom = SkLeftShift(shiftedClip.fBottom, shiftEdgesUp);
 
    SkBasicEdgeBuilder builder(shiftEdgesUp);
    int count = builder.buildEdges(path, pathContainedInClip ? nullptr : &shiftedClip);
    SkEdge** list = builder.edgeList();
 
    if (0 == count) {
        if (path.isInverseFillType()) {
            /*
             *  Since we are in inverse-fill, our caller has already drawn above
             *  our top (start_y) and will draw below our bottom (stop_y). Thus
             *  we need to restrict our drawing to the intersection of the clip
             *  and those two limits.
             */
            SkIRect rect = clipRect;
            if (rect.fTop < start_y) {
                rect.fTop = start_y;
            }
            if (rect.fBottom > stop_y) {
                rect.fBottom = stop_y;
            }
            if (!rect.isEmpty()) {
                blitter->blitRect(rect.fLeft << shiftEdgesUp,
                                  rect.fTop << shiftEdgesUp,
                                  rect.width() << shiftEdgesUp,
                                  rect.height() << shiftEdgesUp);
            }
        }
        return;
    }
 
    SkEdge headEdge, tailEdge, *last;
    // this returns the first and last edge after they're sorted into a dlink list
    SkEdge* edge = sort_edges(list, count, &last);
 
    headEdge.fPrev = nullptr;
    headEdge.fNext = edge;
    headEdge.fFirstY = kEDGE_HEAD_Y;
    headEdge.fX = SK_MinS32;
    edge->fPrev = &headEdge;
 
    tailEdge.fPrev = last;
    tailEdge.fNext = nullptr;
    tailEdge.fFirstY = kEDGE_TAIL_Y;
    last->fNext = &tailEdge;
 
    // now edge is the head of the sorted linklist
 
    start_y = SkLeftShift(start_y, shiftEdgesUp);
    stop_y = SkLeftShift(stop_y, shiftEdgesUp);
    if (!pathContainedInClip && start_y < shiftedClip.fTop) {
        start_y = shiftedClip.fTop;
    }
    if (!pathContainedInClip && stop_y > shiftedClip.fBottom) {
        stop_y = shiftedClip.fBottom;
    }
 
    InverseBlitter  ib;
    PrePostProc     proc = nullptr;
 
    if (path.isInverseFillType()) {
        ib.setBlitter(blitter, clipRect, shiftEdgesUp);
        blitter = &ib;
        proc = PrePostInverseBlitterProc;
    }
 
    // count >= 2 is required as the convex walker does not handle missing right edges
    if (path.isConvex() && (nullptr == proc) && count >= 2) {
        walk_simple_edges(&headEdge, blitter, start_y, stop_y);
    } else {
        walk_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, proc,
                   shiftedClip.right());
    }
}