SkOpBuilder Class Reference

#include <SkPathOps.h>

Public Member Functions
void	add (const SkPath &path, SkPathOp _operator)
bool	resolve (SkPath *result)

Detailed Description

Perform a series of path operations, optimized for unioning many paths together.

Definition at line 86 of file SkPathOps.h.

Member Function Documentation

add()

void SkOpBuilder::add	(	const SkPath &	path,
		SkPathOp	_operator
	)

Add one or more paths and their operand. The builder is empty before the first path is added, so the result of a single add is (emptyPath OP path).

Parameters

path	The second operand.
_operator	The operator to apply to the existing and supplied paths.

Definition at line 126 of file SkOpBuilder.cpp.

                                                     {
    if (fOps.empty() && op != kUnion_SkPathOp) {
        fPathRefs.push_back() = SkPath();
        *fOps.append() = kUnion_SkPathOp;
    }
    fPathRefs.push_back() = path;
    *fOps.append() = op;
}

resolve()

bool SkOpBuilder::resolve

(

SkPath *

result

)

Computes the sum of all paths and operands, and resets the builder to its initial state.

Parameters

result

The product of the operands.

Returns

True if the operation succeeded.

Definition at line 143 of file SkOpBuilder.cpp.

                                        {
    SkPath original = *result;
    int count = fOps.size();
    bool allUnion = true;
    SkPathFirstDirection firstDir = SkPathFirstDirection::kUnknown;
    for (int index = 0; index < count; ++index) {
        SkPath* test = &fPathRefs[index];
        if (kUnion_SkPathOp != fOps[index] || test->isInverseFillType()) {
            allUnion = false;
            break;
        }
        // If all paths are convex, track direction, reversing as needed.
        if (test->isConvex()) {
            SkPathFirstDirection dir = SkPathPriv::ComputeFirstDirection(*test);
            if (dir == SkPathFirstDirection::kUnknown) {
                allUnion = false;
                break;
            }
            if (firstDir == SkPathFirstDirection::kUnknown) {
                firstDir = dir;
            } else if (firstDir != dir) {
                ReversePath(test);
            }
            continue;
        }
        // If the path is not convex but its bounds do not intersect the others, simplify is enough.
        const SkRect& testBounds = test->getBounds();
        for (int inner = 0; inner < index; ++inner) {
            // OPTIMIZE: check to see if the contour bounds do not intersect other contour bounds?
            if (SkRect::Intersects(fPathRefs[inner].getBounds(), testBounds)) {
                allUnion = false;
                break;
            }
        }
    }
    if (!allUnion) {
        *result = fPathRefs[0];
        for (int index = 1; index < count; ++index) {
            if (!Op(*result, fPathRefs[index], fOps[index], result)) {
                reset();
                *result = original;
                return false;
            }
        }
        reset();
        return true;
    }
    SkPath sum;
    for (int index = 0; index < count; ++index) {
        if (!Simplify(fPathRefs[index], &fPathRefs[index])) {
            reset();
            *result = original;
            return false;
        }
        if (!fPathRefs[index].isEmpty()) {
            // convert the even odd result back to winding form before accumulating it
            if (!FixWinding(&fPathRefs[index])) {
                *result = original;
                return false;
            }
            sum.addPath(fPathRefs[index]);
        }
    }
    reset();
    bool success = Simplify(sum, result);
    if (!success) {
        *result = original;
    }
    return success;
}

---

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

• third_party/skia/include/pathops/SkPathOps.h
• third_party/skia/src/pathops/SkOpBuilder.cpp