SkGlyph.cpp File Reference

#include "src/core/SkGlyph.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkData.h"
#include "include/core/SkDrawable.h"
#include "include/core/SkPicture.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSerialProcs.h"
#include "include/core/SkSpan.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTFitsIn.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkArenaAlloc.h"
#include "src/base/SkBezierCurves.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkScalerContext.h"
#include "src/core/SkWriteBuffer.h"
#include "src/text/StrikeForGPU.h"
#include <cstring>
#include <optional>
#include <tuple>
#include <utility>

Go to the source code of this file.

Functions
static size_t	bits_to_bytes (size_t bits)
static size_t	format_alignment (SkMask::Format format)
static size_t	format_rowbytes (int width, SkMask::Format format)
static std::tuple< SkScalar, SkScalar >	calculate_path_gap (SkScalar topOffset, SkScalar bottomOffset, const SkPath &path)

Function Documentation

bits_to_bytes()

static size_t bits_to_bytes ( size_t  bits )

static

Definition at line 146 of file SkGlyph.cpp.

                                         {
    return (bits + 7) >> 3;
}

calculate_path_gap()

static std::tuple< SkScalar, SkScalar > calculate_path_gap ( SkScalar  topOffset, SkScalar  bottomOffset, const SkPath &  path  )

static

Definition at line 440 of file SkGlyph.cpp.

                                                                       {
 
    // Left and Right of an ever expanding gap around the path.
    SkScalar left  = SK_ScalarMax,
             right = SK_ScalarMin;
 
    auto expandGap = [&left, &right](SkScalar v) {
        left  = std::min(left, v);
        right = std::max(right, v);
    };
 
    // Handle all the different verbs for the path.
    SkPoint pts[4];
    auto addLine = [&](SkScalar offset) {
        SkScalar t = sk_ieee_float_divide(offset - pts[0].fY, pts[1].fY - pts[0].fY);
        if (0 <= t && t < 1) {   // this handles divide by zero above
            expandGap(pts[0].fX + t * (pts[1].fX - pts[0].fX));
        }
    };
 
    auto addQuad = [&](SkScalar offset) {
        SkScalar intersectionStorage[2];
        auto intersections = SkBezierQuad::IntersectWithHorizontalLine(
                SkSpan(pts, 3), offset, intersectionStorage);
        for (SkScalar x : intersections) {
            expandGap(x);
        }
    };
 
    auto addCubic = [&](SkScalar offset) {
        float intersectionStorage[3];
        auto intersections = SkBezierCubic::IntersectWithHorizontalLine(
                SkSpan{pts, 4}, offset, intersectionStorage);
 
        for(double intersection : intersections) {
            expandGap(intersection);
        }
    };
 
    // Handle when a verb's points are in the gap between top and bottom.
    auto addPts = [&expandGap, &pts, topOffset, bottomOffset](int ptCount) {
        for (int i = 0; i < ptCount; ++i) {
            if (topOffset < pts[i].fY && pts[i].fY < bottomOffset) {
                expandGap(pts[i].fX);
            }
        }
    };
 
    SkPath::Iter iter(path, false);
    SkPath::Verb verb;
    while (SkPath::kDone_Verb != (verb = iter.next(pts))) {
        switch (verb) {
            case SkPath::kMove_Verb: {
                break;
            }
            case SkPath::kLine_Verb: {
                auto [lineTop, lineBottom] = std::minmax({pts[0].fY, pts[1].fY});
 
                // The y-coordinates of the points intersect the top and bottom offsets.
                if (topOffset <= lineBottom && lineTop <= bottomOffset) {
                    addLine(topOffset);
                    addLine(bottomOffset);
                    addPts(2);
                }
                break;
            }
            case SkPath::kQuad_Verb: {
                auto [quadTop, quadBottom] = std::minmax({pts[0].fY, pts[1].fY, pts[2].fY});
 
                // The y-coordinates of the points intersect the top and bottom offsets.
                if (topOffset <= quadBottom && quadTop <= bottomOffset) {
                    addQuad(topOffset);
                    addQuad(bottomOffset);
                    addPts(3);
                }
                break;
            }
            case SkPath::kConic_Verb: {
                SkDEBUGFAIL("There should be no conic primitives in glyph outlines.");
                break;
            }
            case SkPath::kCubic_Verb: {
                auto [cubicTop, cubicBottom] =
                        std::minmax({pts[0].fY, pts[1].fY, pts[2].fY, pts[3].fY});
 
                // The y-coordinates of the points intersect the top and bottom offsets.
                if (topOffset <= cubicBottom && cubicTop <= bottomOffset) {
                    addCubic(topOffset);
                    addCubic(bottomOffset);
                    addPts(4);
                }
                break;
            }
            case SkPath::kClose_Verb: {
                break;
            }
            default: {
                SkDEBUGFAIL("Unknown path verb generating glyph underline.");
                break;
            }
        }
    }
 
    return std::tie(left, right);
}

format_alignment()

static size_t format_alignment ( SkMask::Format  format )

static

Definition at line 150 of file SkGlyph.cpp.

                                                    {
    switch (format) {
        case SkMask::kBW_Format:
        case SkMask::kA8_Format:
        case SkMask::k3D_Format:
        case SkMask::kSDF_Format:
            return alignof(uint8_t);
        case SkMask::kARGB32_Format:
            return alignof(uint32_t);
        case SkMask::kLCD16_Format:
            return alignof(uint16_t);
        default:
            SK_ABORT("Unknown mask format.");
            break;
    }
    return 0;
}

format_rowbytes()

static size_t format_rowbytes ( int  width, SkMask::Format  format  )

static

Definition at line 168 of file SkGlyph.cpp.

                                                              {
    return format == SkMask::kBW_Format ? bits_to_bytes(width)
                                        : width * format_alignment(format);
}