123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780 |
- /*
- * Copyright 2006 The Android Open Source Project
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #include "include/core/SkPath.h"
- #include "include/core/SkRegion.h"
- #include "include/private/SkMacros.h"
- #include "include/private/SkSafe32.h"
- #include "include/private/SkTemplates.h"
- #include "src/core/SkBlitter.h"
- #include "src/core/SkEdge.h"
- #include "src/core/SkEdgeBuilder.h"
- #include "src/core/SkGeometry.h"
- #include "src/core/SkQuadClipper.h"
- #include "src/core/SkRasterClip.h"
- #include "src/core/SkRectPriv.h"
- #include "src/core/SkScanPriv.h"
- #include "src/core/SkTSort.h"
- #include <utility>
- #define kEDGE_HEAD_Y SK_MinS32
- #define kEDGE_TAIL_Y SK_MaxS32
- #ifdef SK_DEBUG
- static void validate_sort(const SkEdge* edge) {
- int y = kEDGE_HEAD_Y;
- while (edge->fFirstY != SK_MaxS32) {
- edge->validate();
- SkASSERT(y <= edge->fFirstY);
- y = edge->fFirstY;
- edge = edge->fNext;
- }
- }
- #else
- #define validate_sort(edge)
- #endif
- static void insert_new_edges(SkEdge* newEdge, int curr_y) {
- if (newEdge->fFirstY != curr_y) {
- return;
- }
- SkEdge* prev = newEdge->fPrev;
- if (prev->fX <= newEdge->fX) {
- return;
- }
- // find first x pos to insert
- SkEdge* start = backward_insert_start(prev, newEdge->fX);
- // insert the lot, fixing up the links as we go
- do {
- SkEdge* next = newEdge->fNext;
- do {
- if (start->fNext == newEdge) {
- goto nextEdge;
- }
- SkEdge* after = start->fNext;
- if (after->fX >= newEdge->fX) {
- break;
- }
- start = after;
- } while (true);
- remove_edge(newEdge);
- insert_edge_after(newEdge, start);
- nextEdge:
- start = newEdge;
- newEdge = next;
- } while (newEdge->fFirstY == curr_y);
- }
- #ifdef SK_DEBUG
- static void validate_edges_for_y(const SkEdge* edge, int curr_y) {
- while (edge->fFirstY <= curr_y) {
- SkASSERT(edge->fPrev && edge->fNext);
- SkASSERT(edge->fPrev->fNext == edge);
- SkASSERT(edge->fNext->fPrev == edge);
- SkASSERT(edge->fFirstY <= edge->fLastY);
- SkASSERT(edge->fPrev->fX <= edge->fX);
- edge = edge->fNext;
- }
- }
- #else
- #define validate_edges_for_y(edge, curr_y)
- #endif
- #if defined _WIN32 // disable warning : local variable used without having been initialized
- #pragma warning ( push )
- #pragma warning ( disable : 4701 )
- #endif
- typedef void (*PrePostProc)(SkBlitter* blitter, int y, bool isStartOfScanline);
- #define PREPOST_START true
- #define PREPOST_END false
- static void walk_edges(SkEdge* prevHead, SkPath::FillType fillType,
- SkBlitter* blitter, int start_y, int stop_y,
- PrePostProc proc, int rightClip) {
- validate_sort(prevHead->fNext);
- int curr_y = start_y;
- // returns 1 for evenodd, -1 for winding, regardless of inverse-ness
- int windingMask = (fillType & 1) ? 1 : -1;
- for (;;) {
- int w = 0;
- int left SK_INIT_TO_AVOID_WARNING;
- SkEdge* currE = prevHead->fNext;
- SkFixed prevX = prevHead->fX;
- validate_edges_for_y(currE, curr_y);
- if (proc) {
- proc(blitter, curr_y, PREPOST_START); // pre-proc
- }
- while (currE->fFirstY <= curr_y) {
- SkASSERT(currE->fLastY >= curr_y);
- int x = SkFixedRoundToInt(currE->fX);
- if ((w & windingMask) == 0) { // we're starting interval
- left = x;
- }
- w += currE->fWinding;
- if ((w & windingMask) == 0) { // we finished an interval
- int width = x - left;
- SkASSERT(width >= 0);
- if (width > 0) {
- blitter->blitH(left, curr_y, width);
- }
- }
- SkEdge* next = currE->fNext;
- SkFixed newX;
- if (currE->fLastY == curr_y) { // are we done with this edge?
- if (currE->fCurveCount > 0) {
- if (((SkQuadraticEdge*)currE)->updateQuadratic()) {
- newX = currE->fX;
- goto NEXT_X;
- }
- } else if (currE->fCurveCount < 0) {
- if (((SkCubicEdge*)currE)->updateCubic()) {
- SkASSERT(currE->fFirstY == curr_y + 1);
- newX = currE->fX;
- goto NEXT_X;
- }
- }
- remove_edge(currE);
- } else {
- SkASSERT(currE->fLastY > curr_y);
- newX = currE->fX + currE->fDX;
- currE->fX = newX;
- NEXT_X:
- if (newX < prevX) { // ripple currE backwards until it is x-sorted
- backward_insert_edge_based_on_x(currE);
- } else {
- prevX = newX;
- }
- }
- currE = next;
- SkASSERT(currE);
- }
- if ((w & windingMask) != 0) { // was our right-edge culled away?
- int width = rightClip - left;
- if (width > 0) {
- blitter->blitH(left, curr_y, width);
- }
- }
- if (proc) {
- proc(blitter, curr_y, PREPOST_END); // post-proc
- }
- curr_y += 1;
- if (curr_y >= stop_y) {
- break;
- }
- // now currE points to the first edge with a Yint larger than curr_y
- insert_new_edges(currE, curr_y);
- }
- }
- // return true if we're NOT done with this edge
- static bool update_edge(SkEdge* edge, int last_y) {
- SkASSERT(edge->fLastY >= last_y);
- if (last_y == edge->fLastY) {
- if (edge->fCurveCount < 0) {
- if (((SkCubicEdge*)edge)->updateCubic()) {
- SkASSERT(edge->fFirstY == last_y + 1);
- return true;
- }
- } else if (edge->fCurveCount > 0) {
- if (((SkQuadraticEdge*)edge)->updateQuadratic()) {
- SkASSERT(edge->fFirstY == last_y + 1);
- return true;
- }
- }
- return false;
- }
- return true;
- }
- // Unexpected conditions for which we need to return
- #define ASSERT_RETURN(cond) \
- do { \
- if (!(cond)) { \
- SkASSERT(false); \
- return; \
- } \
- } while (0)
- // Needs Y to only change once (looser than convex in X)
- static void walk_simple_edges(SkEdge* prevHead, SkBlitter* blitter, int start_y, int stop_y) {
- validate_sort(prevHead->fNext);
- SkEdge* leftE = prevHead->fNext;
- SkEdge* riteE = leftE->fNext;
- SkEdge* currE = riteE->fNext;
- // our edge choppers for curves can result in the initial edges
- // not lining up, so we take the max.
- int local_top = SkMax32(leftE->fFirstY, riteE->fFirstY);
- ASSERT_RETURN(local_top >= start_y);
- while (local_top < stop_y) {
- SkASSERT(leftE->fFirstY <= stop_y);
- SkASSERT(riteE->fFirstY <= stop_y);
- int local_bot = SkMin32(leftE->fLastY, riteE->fLastY);
- local_bot = SkMin32(local_bot, stop_y - 1);
- ASSERT_RETURN(local_top <= local_bot);
- SkFixed left = leftE->fX;
- SkFixed dLeft = leftE->fDX;
- SkFixed rite = riteE->fX;
- SkFixed dRite = riteE->fDX;
- int count = local_bot - local_top;
- ASSERT_RETURN(count >= 0);
- if (0 == (dLeft | dRite)) {
- int L = SkFixedRoundToInt(left);
- int R = SkFixedRoundToInt(rite);
- if (L > R) {
- std::swap(L, R);
- }
- if (L < R) {
- count += 1;
- blitter->blitRect(L, local_top, R - L, count);
- }
- local_top = local_bot + 1;
- } else {
- do {
- int L = SkFixedRoundToInt(left);
- int R = SkFixedRoundToInt(rite);
- if (L > R) {
- std::swap(L, R);
- }
- if (L < R) {
- blitter->blitH(L, local_top, R - L);
- }
- // Either/both of these might overflow, since we perform this step even if
- // (later) we determine that we are done with the edge, and so the computed
- // left or rite edge will not be used (see update_edge). Use this helper to
- // silence UBSAN when we perform the add.
- left = Sk32_can_overflow_add(left, dLeft);
- rite = Sk32_can_overflow_add(rite, dRite);
- local_top += 1;
- } while (--count >= 0);
- }
- leftE->fX = left;
- riteE->fX = rite;
- if (!update_edge(leftE, local_bot)) {
- if (currE->fFirstY >= stop_y) {
- return; // we're done
- }
- leftE = currE;
- currE = currE->fNext;
- ASSERT_RETURN(leftE->fFirstY == local_top);
- }
- if (!update_edge(riteE, local_bot)) {
- if (currE->fFirstY >= stop_y) {
- return; // we're done
- }
- riteE = currE;
- currE = currE->fNext;
- ASSERT_RETURN(riteE->fFirstY == local_top);
- }
- }
- }
- ///////////////////////////////////////////////////////////////////////////////
- // this guy overrides blitH, and will call its proxy blitter with the inverse
- // of the spans it is given (clipped to the left/right of the cliprect)
- //
- // used to implement inverse filltypes on paths
- //
- class InverseBlitter : public SkBlitter {
- public:
- void setBlitter(SkBlitter* blitter, const SkIRect& clip, int shift) {
- fBlitter = blitter;
- fFirstX = clip.fLeft << shift;
- fLastX = clip.fRight << shift;
- }
- void prepost(int y, bool isStart) {
- if (isStart) {
- fPrevX = fFirstX;
- } else {
- int invWidth = fLastX - fPrevX;
- if (invWidth > 0) {
- fBlitter->blitH(fPrevX, y, invWidth);
- }
- }
- }
- // overrides
- void blitH(int x, int y, int width) override {
- int invWidth = x - fPrevX;
- if (invWidth > 0) {
- fBlitter->blitH(fPrevX, y, invWidth);
- }
- fPrevX = x + width;
- }
- // we do not expect to get called with these entrypoints
- void blitAntiH(int, int, const SkAlpha[], const int16_t runs[]) override {
- SkDEBUGFAIL("blitAntiH unexpected");
- }
- void blitV(int x, int y, int height, SkAlpha alpha) override {
- SkDEBUGFAIL("blitV unexpected");
- }
- void blitRect(int x, int y, int width, int height) override {
- SkDEBUGFAIL("blitRect unexpected");
- }
- void blitMask(const SkMask&, const SkIRect& clip) override {
- SkDEBUGFAIL("blitMask unexpected");
- }
- const SkPixmap* justAnOpaqueColor(uint32_t* value) override {
- SkDEBUGFAIL("justAnOpaqueColor unexpected");
- return nullptr;
- }
- private:
- SkBlitter* fBlitter;
- int fFirstX, fLastX, fPrevX;
- };
- static void PrePostInverseBlitterProc(SkBlitter* blitter, int y, bool isStart) {
- ((InverseBlitter*)blitter)->prepost(y, isStart);
- }
- ///////////////////////////////////////////////////////////////////////////////
- #if defined _WIN32
- #pragma warning ( pop )
- #endif
- static bool operator<(const SkEdge& a, const SkEdge& b) {
- int valuea = a.fFirstY;
- int valueb = b.fFirstY;
- if (valuea == valueb) {
- valuea = a.fX;
- valueb = b.fX;
- }
- return valuea < valueb;
- }
- static SkEdge* sort_edges(SkEdge* list[], int count, SkEdge** last) {
- SkTQSort(list, list + count - 1);
- // now make the edges linked in sorted order
- for (int i = 1; i < count; i++) {
- list[i - 1]->fNext = list[i];
- list[i]->fPrev = list[i - 1];
- }
- *last = list[count - 1];
- return list[0];
- }
- // clipRect has not been shifted up
- void sk_fill_path(const SkPath& path, const SkIRect& clipRect, SkBlitter* blitter,
- int start_y, int stop_y, int shiftEdgesUp, bool pathContainedInClip) {
- 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());
- }
- }
- void sk_blit_above(SkBlitter* blitter, const SkIRect& ir, const SkRegion& clip) {
- 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);
- }
- }
- void sk_blit_below(SkBlitter* blitter, const SkIRect& ir, const SkRegion& clip) {
- 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);
- }
- }
- ///////////////////////////////////////////////////////////////////////////////
- /**
- * If the caller is drawing an inverse-fill path, then it pass true for
- * skipRejectTest, so we don't abort drawing just because the src bounds (ir)
- * is outside of the clip.
- */
- SkScanClipper::SkScanClipper(SkBlitter* blitter, const SkRegion* clip,
- const SkIRect& ir, bool skipRejectTest, bool irPreClipped) {
- fBlitter = nullptr; // null means blit nothing
- fClipRect = nullptr;
- if (clip) {
- fClipRect = &clip->getBounds();
- if (!skipRejectTest && !SkIRect::Intersects(*fClipRect, ir)) { // completely clipped out
- return;
- }
- if (clip->isRect()) {
- if (!irPreClipped && fClipRect->contains(ir)) {
- #ifdef SK_DEBUG
- fRectClipCheckBlitter.init(blitter, *fClipRect);
- blitter = &fRectClipCheckBlitter;
- #endif
- fClipRect = nullptr;
- } else {
- // only need a wrapper blitter if we're horizontally clipped
- if (irPreClipped ||
- fClipRect->fLeft > ir.fLeft || fClipRect->fRight < ir.fRight) {
- fRectBlitter.init(blitter, *fClipRect);
- blitter = &fRectBlitter;
- } else {
- #ifdef SK_DEBUG
- fRectClipCheckBlitter.init(blitter, *fClipRect);
- blitter = &fRectClipCheckBlitter;
- #endif
- }
- }
- } else {
- fRgnBlitter.init(blitter, clip);
- blitter = &fRgnBlitter;
- }
- }
- fBlitter = blitter;
- }
- ///////////////////////////////////////////////////////////////////////////////
- static bool clip_to_limit(const SkRegion& orig, SkRegion* reduced) {
- // need to limit coordinates such that the width/height of our rect can be represented
- // in SkFixed (16.16). See skbug.com/7998
- const int32_t limit = 32767 >> 1;
- SkIRect limitR;
- limitR.set(-limit, -limit, limit, limit);
- if (limitR.contains(orig.getBounds())) {
- return false;
- }
- reduced->op(orig, limitR, SkRegion::kIntersect_Op);
- return true;
- }
- // Bias used for conservative rounding of float rects to int rects, to nudge the irects a little
- // larger, so we don't "think" a path's bounds are inside a clip, when (due to numeric drift in
- // the scan-converter) we might walk beyond the predicted limits.
- //
- // This value has been determined trial and error: pick the smallest value (after the 0.5) that
- // fixes any problematic cases (e.g. crbug.com/844457)
- // NOTE: cubics appear to be the main reason for needing this slop. If we could (perhaps) have a
- // more accurate walker for cubics, we may be able to reduce this fudge factor.
- static const double kConservativeRoundBias = 0.5 + 1.5 / SK_FDot6One;
- /**
- * Round the value down. This is used to round the top and left of a rectangle,
- * and corresponds to the way the scan converter treats the top and left edges.
- * It has a slight bias to make the "rounded" int smaller than a normal round, to create a more
- * conservative int-bounds (larger) from a float rect.
- */
- static inline int round_down_to_int(SkScalar x) {
- double xx = x;
- xx -= kConservativeRoundBias;
- return sk_double_saturate2int(ceil(xx));
- }
- /**
- * Round the value up. This is used to round the right and bottom of a rectangle.
- * It has a slight bias to make the "rounded" int smaller than a normal round, to create a more
- * conservative int-bounds (larger) from a float rect.
- */
- static inline int round_up_to_int(SkScalar x) {
- double xx = x;
- xx += kConservativeRoundBias;
- return sk_double_saturate2int(floor(xx));
- }
- /*
- * Conservative rounding function, which effectively nudges the int-rect to be slightly larger
- * than SkRect::round() might have produced. This is a safety-net for the scan-converter, which
- * inspects the returned int-rect, and may disable clipping (for speed) if it thinks all of the
- * edges will fit inside the clip's bounds. The scan-converter introduces slight numeric errors
- * due to accumulated += of the slope, so this function is used to return a conservatively large
- * int-bounds, and thus we will only disable clipping if we're sure the edges will stay in-bounds.
- */
- static SkIRect conservative_round_to_int(const SkRect& src) {
- return {
- round_down_to_int(src.fLeft),
- round_down_to_int(src.fTop),
- round_up_to_int(src.fRight),
- round_up_to_int(src.fBottom),
- };
- }
- void SkScan::FillPath(const SkPath& path, const SkRegion& origClip,
- SkBlitter* blitter) {
- 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???
- }
- }
- void SkScan::FillPath(const SkPath& path, const SkIRect& ir,
- SkBlitter* blitter) {
- SkRegion rgn(ir);
- FillPath(path, rgn, blitter);
- }
- ///////////////////////////////////////////////////////////////////////////////
- static int build_tri_edges(SkEdge edge[], const SkPoint pts[],
- const SkIRect* clipRect, SkEdge* list[]) {
- SkEdge** start = list;
- if (edge->setLine(pts[0], pts[1], clipRect, 0)) {
- *list++ = edge;
- edge = (SkEdge*)((char*)edge + sizeof(SkEdge));
- }
- if (edge->setLine(pts[1], pts[2], clipRect, 0)) {
- *list++ = edge;
- edge = (SkEdge*)((char*)edge + sizeof(SkEdge));
- }
- if (edge->setLine(pts[2], pts[0], clipRect, 0)) {
- *list++ = edge;
- }
- return (int)(list - start);
- }
- static void sk_fill_triangle(const SkPoint pts[], const SkIRect* clipRect,
- SkBlitter* blitter, const SkIRect& ir) {
- SkASSERT(pts && blitter);
- SkEdge edgeStorage[3];
- SkEdge* list[3];
- int count = build_tri_edges(edgeStorage, pts, clipRect, list);
- if (count < 2) {
- 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
- int stop_y = ir.fBottom;
- if (clipRect && stop_y > clipRect->fBottom) {
- stop_y = clipRect->fBottom;
- }
- int start_y = ir.fTop;
- if (clipRect && start_y < clipRect->fTop) {
- start_y = clipRect->fTop;
- }
- walk_simple_edges(&headEdge, blitter, start_y, stop_y);
- }
- void SkScan::FillTriangle(const SkPoint pts[], const SkRasterClip& clip,
- SkBlitter* blitter) {
- if (clip.isEmpty()) {
- return;
- }
- SkRect r;
- r.set(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);
- }
- }
|