SkRegion_path.cpp File Reference

#include "include/core/SkColor.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPath.h"
#include "include/core/SkRect.h"
#include "include/core/SkRegion.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkPoint_impl.h"
#include "include/private/base/SkTDArray.h"
#include "include/private/base/SkTFitsIn.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkSafeMath.h"
#include "src/base/SkTSort.h"
#include "src/core/SkBlitter.h"
#include "src/core/SkRegionPriv.h"
#include "src/core/SkScan.h"
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <iterator>

Go to the source code of this file.

Classes
class	SkRgnBuilder
struct	Edge
struct	EdgeLT

Functions
static bool	sk_memeq32 (const int32_t *SK_RESTRICT a, const int32_t *SK_RESTRICT b, int count)
static unsigned	verb_to_initial_last_index (unsigned verb)
static unsigned	verb_to_max_edges (unsigned verb)
static int	count_path_runtype_values (const SkPath &path, int *itop, int *ibot)
static bool	check_inverse_on_empty_return (SkRegion *dst, const SkPath &path, const SkRegion &clip)
static void	find_link (Edge *base, Edge *stop)
static int	extract_path (Edge *edge, Edge *stop, SkPath *path)

Function Documentation

check_inverse_on_empty_return()

static bool check_inverse_on_empty_return ( SkRegion *  dst, const SkPath &  path, const SkRegion &  clip  )

static

Definition at line 330 of file SkRegion_path.cpp.

                                                                                                   {
    if (path.isInverseFillType()) {
        return dst->set(clip);
    } else {
        return dst->setEmpty();
    }
}

count_path_runtype_values()

static int count_path_runtype_values ( const SkPath &  path, int *  itop, int *  ibot  )

static

Definition at line 291 of file SkRegion_path.cpp.

                                                                               {
    SkPath::Iter    iter(path, true);
    SkPoint         pts[4];
    SkPath::Verb    verb;
 
    int maxEdges = 0;
    SkScalar    top = SkIntToScalar(SK_MaxS16);
    SkScalar    bot = SkIntToScalar(SK_MinS16);
 
    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
        maxEdges += verb_to_max_edges(verb);
 
        int lastIndex = verb_to_initial_last_index(verb);
        if (lastIndex > 0) {
            for (int i = 1; i <= lastIndex; i++) {
                if (top > pts[i].fY) {
                    top = pts[i].fY;
                } else if (bot < pts[i].fY) {
                    bot = pts[i].fY;
                }
            }
        } else if (SkPath::kMove_Verb == verb) {
            if (top > pts[0].fY) {
                top = pts[0].fY;
            } else if (bot < pts[0].fY) {
                bot = pts[0].fY;
            }
        }
    }
    if (0 == maxEdges) {
        return 0;   // we have only moves+closes
    }
 
    SkASSERT(top <= bot);
    *itop = SkScalarRoundToInt(top);
    *ibot = SkScalarRoundToInt(bot);
    return maxEdges;
}

extract_path()

static int extract_path ( Edge *  edge, Edge *  stop, SkPath *  path  )

static

Definition at line 515 of file SkRegion_path.cpp.

                                                              {
    while (0 == edge->fFlags) {
        edge++; // skip over "used" edges
    }
 
    SkASSERT(edge < stop);
 
    Edge* base = edge;
    Edge* prev = edge;
    edge = edge->fNext;
    SkASSERT(edge != base);
 
    int count = 1;
    path->moveTo(SkIntToScalar(prev->fX), SkIntToScalar(prev->fY0));
    prev->fFlags = 0;
    do {
        if (prev->fX != edge->fX || prev->fY1 != edge->fY0) { // skip collinear
            path->lineTo(SkIntToScalar(prev->fX), SkIntToScalar(prev->fY1));    // V
            path->lineTo(SkIntToScalar(edge->fX), SkIntToScalar(edge->fY0));    // H
        }
        prev = edge;
        edge = edge->fNext;
        count += 1;
        prev->fFlags = 0;
    } while (edge != base);
    path->lineTo(SkIntToScalar(prev->fX), SkIntToScalar(prev->fY1));    // V
    path->close();
    return count;
}

find_link()

static void find_link ( Edge *  base, Edge *  stop  )

static

Definition at line 473 of file SkRegion_path.cpp.

                                              {
    SkASSERT(base < stop);
 
    if (base->fFlags == Edge::kCompleteLink) {
        SkASSERT(base->fNext);
        return;
    }
 
    SkASSERT(base + 1 < stop);
 
    int y0 = base->fY0;
    int y1 = base->fY1;
 
    Edge* e = base;
    if ((base->fFlags & Edge::kY0Link) == 0) {
        for (;;) {
            e += 1;
            if ((e->fFlags & Edge::kY1Link) == 0 && y0 == e->fY1) {
                SkASSERT(nullptr == e->fNext);
                e->fNext = base;
                e->fFlags = SkToU8(e->fFlags | Edge::kY1Link);
                break;
            }
        }
    }
 
    e = base;
    if ((base->fFlags & Edge::kY1Link) == 0) {
        for (;;) {
            e += 1;
            if ((e->fFlags & Edge::kY0Link) == 0 && y1 == e->fY0) {
                SkASSERT(nullptr == base->fNext);
                base->fNext = e;
                e->fFlags = SkToU8(e->fFlags | Edge::kY0Link);
                break;
            }
        }
    }
 
    base->fFlags = Edge::kCompleteLink;
}

sk_memeq32()

static bool sk_memeq32 ( const int32_t *SK_RESTRICT  a, const int32_t *SK_RESTRICT  b, int  count  )

static

Definition at line 35 of file SkRegion_path.cpp.

                                                                                              {
    for (int i = 0; i < count; ++i) {
        if (a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

verb_to_initial_last_index()

static unsigned verb_to_initial_last_index ( unsigned  verb )

static

Definition at line 262 of file SkRegion_path.cpp.

                                                          {
    static const uint8_t gPathVerbToInitialLastIndex[] = {
        0,  //  kMove_Verb
        1,  //  kLine_Verb
        2,  //  kQuad_Verb
        2,  //  kConic_Verb
        3,  //  kCubic_Verb
        0,  //  kClose_Verb
        0   //  kDone_Verb
    };
    SkASSERT((unsigned)verb < std::size(gPathVerbToInitialLastIndex));
    return gPathVerbToInitialLastIndex[verb];
}

verb_to_max_edges()

static unsigned verb_to_max_edges ( unsigned  verb )

static

Definition at line 276 of file SkRegion_path.cpp.

                                                 {
    static const uint8_t gPathVerbToMaxEdges[] = {
        0,  //  kMove_Verb
        1,  //  kLine_Verb
        2,  //  kQuad_VerbB
        2,  //  kConic_VerbB
        3,  //  kCubic_Verb
        0,  //  kClose_Verb
        0   //  kDone_Verb
    };
    SkASSERT((unsigned)verb < std::size(gPathVerbToMaxEdges));
    return gPathVerbToMaxEdges[verb];
}