GrDistanceFieldGenFromVector.h File Reference

#include "include/core/SkPath.h"

Go to the source code of this file.

Functions
bool	GrGenerateDistanceFieldFromPath (unsigned char *distanceField, const SkPath &path, const SkMatrix &viewMatrix, int width, int height, size_t rowBytes)
bool	IsDistanceFieldSupportedFillType (SkPathFillType fFillType)

Function Documentation

GrGenerateDistanceFieldFromPath()

bool GrGenerateDistanceFieldFromPath	(	unsigned char *	distanceField,
		const SkPath &	path,
		const SkMatrix &	viewMatrix,
		int	width,
		int	height,
		size_t	rowBytes
	)

Given a vector path, generate the associated distance field.

Parameters

distanceField	The distance field to be generated. Should already be allocated by the client with the padding defined in "SkDistanceFieldGen.h".
path	The path we're using to generate the distance field.
matrix	Transformation matrix for path.
width	Width of the distance field.
height	Height of the distance field.
rowBytes	Size of each row in the distance field, in bytes.

Definition at line 721 of file GrDistanceFieldGenFromVector.cpp.

                                                                             {
    SkASSERT(distanceField);
 
    // transform to device space, then:
    // translate path to offset (SK_DistanceFieldPad, SK_DistanceFieldPad)
    SkMatrix dfMatrix(drawMatrix);
    dfMatrix.postTranslate(SK_DistanceFieldPad, SK_DistanceFieldPad);
 
#ifdef SK_DEBUG
    SkPath xformPath;
    path.transform(dfMatrix, &xformPath);
    SkIRect pathBounds = xformPath.getBounds().roundOut();
    SkIRect expectPathBounds = SkIRect::MakeWH(width, height);
#endif
 
    SkASSERT(expectPathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds.fLeft, pathBounds.fTop));
    SkASSERT(expectPathBounds.isEmpty() || pathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds));
 
// TODO: restore when Simplify() is working correctly
//       see https://bugs.chromium.org/p/skia/issues/detail?id=9732
//    SkPath simplifiedPath;
    SkPath workingPath;
//    if (Simplify(path, &simplifiedPath)) {
//        workingPath = simplifiedPath;
//    } else {
        workingPath = path;
//    }
    // only even-odd and inverse even-odd supported
    if (!IsDistanceFieldSupportedFillType(workingPath.getFillType())) {
        return false;
    }
 
    // transform to device space + SDF offset
    // TODO: remove degenerate segments while doing this?
    workingPath.transform(dfMatrix);
 
    SkDEBUGCODE(pathBounds = workingPath.getBounds().roundOut());
    SkASSERT(expectPathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds.fLeft, pathBounds.fTop));
    SkASSERT(expectPathBounds.isEmpty() || pathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds));
 
    // create temp data
    size_t dataSize = width * height * sizeof(DFData);
    SkAutoSMalloc<1024> dfStorage(dataSize);
    DFData* dataPtr = (DFData*) dfStorage.get();
 
    // create initial distance data (init to "far away")
    init_distances(dataPtr, width * height);
 
    // polygonize path into line and quad segments
    SkPathEdgeIter iter(workingPath);
    STArray<15, PathSegment, true> segments;
    while (auto e = iter.next()) {
        switch (e.fEdge) {
            case SkPathEdgeIter::Edge::kLine: {
                add_line(e.fPts, &segments);
                break;
            }
            case SkPathEdgeIter::Edge::kQuad:
                add_quad(e.fPts, &segments);
                break;
            case SkPathEdgeIter::Edge::kConic: {
                SkScalar weight = iter.conicWeight();
                SkAutoConicToQuads converter;
                const SkPoint* quadPts = converter.computeQuads(e.fPts, weight, kConicTolerance);
                for (int i = 0; i < converter.countQuads(); ++i) {
                    add_quad(quadPts + 2*i, &segments);
                }
                break;
            }
            case SkPathEdgeIter::Edge::kCubic: {
                add_cubic(e.fPts, &segments);
                break;
            }
        }
    }
 
    // do all the work
    calculate_distance_field_data(&segments, dataPtr, width, height);
 
    // adjust distance based on winding
    for (int row = 0; row < height; ++row) {
        using DFSign = int;
        constexpr DFSign kInside = -1;
        constexpr DFSign kOutside = 1;
 
        int windingNumber = 0;  // Winding number start from zero for each scanline
        for (int col = 0; col < width; ++col) {
            int idx = (row * width) + col;
            windingNumber += dataPtr[idx].fDeltaWindingScore;
 
            DFSign dfSign;
            switch (workingPath.getFillType()) {
                case SkPathFillType::kWinding:
                    dfSign = windingNumber ? kInside : kOutside;
                    break;
                case SkPathFillType::kInverseWinding:
                    dfSign = windingNumber ? kOutside : kInside;
                    break;
                case SkPathFillType::kEvenOdd:
                    dfSign = (windingNumber % 2) ? kInside : kOutside;
                    break;
                case SkPathFillType::kInverseEvenOdd:
                    dfSign = (windingNumber % 2) ? kOutside : kInside;
                    break;
            }
 
            const float miniDist = sqrt(dataPtr[idx].fDistSq);
            const float dist = dfSign * miniDist;
 
            unsigned char pixelVal = pack_distance_field_val<SK_DistanceFieldMagnitude>(dist);
 
            distanceField[(row * rowBytes) + col] = pixelVal;
        }
 
        // The winding number at the end of a scanline should be zero.
        if (windingNumber != 0) {
            SkDEBUGFAIL("Winding number should be zero at the end of a scan line.");
            // Fallback to use SkPath::contains to determine the sign of pixel in release build.
            for (int col = 0; col < width; ++col) {
                int idx = (row * width) + col;
                DFSign dfSign = workingPath.contains(col + 0.5, row + 0.5) ? kInside : kOutside;
                const float miniDist = sqrt(dataPtr[idx].fDistSq);
                const float dist = dfSign * miniDist;
 
                unsigned char pixelVal = pack_distance_field_val<SK_DistanceFieldMagnitude>(dist);
 
                distanceField[(row * rowBytes) + col] = pixelVal;
            }
            continue;
        }
    }
    return true;
}

IsDistanceFieldSupportedFillType()

bool IsDistanceFieldSupportedFillType ( SkPathFillType  fFillType )

inline

Definition at line 31 of file GrDistanceFieldGenFromVector.h.

{
    return (SkPathFillType::kEvenOdd == fFillType ||
            SkPathFillType::kInverseEvenOdd == fFillType);
}