SkPaintPriv Class Reference

#include <SkPaintPriv.h>

Public Types
enum	ShaderOverrideOpacity { kNone_ShaderOverrideOpacity , kOpaque_ShaderOverrideOpacity , kNotOpaque_ShaderOverrideOpacity }

Static Public Member Functions
static bool	Overwrites (const SkPaint *paint, ShaderOverrideOpacity)
static bool	ShouldDither (const SkPaint &, SkColorType)
static SkColor	ComputeLuminanceColor (const SkPaint &)
static void	Flatten (const SkPaint &paint, SkWriteBuffer &buffer)
static SkPaint	Unflatten (SkReadBuffer &buffer)
static void	RemoveColorFilter (SkPaint *, SkColorSpace *dstCS)

Detailed Description

Definition at line 19 of file SkPaintPriv.h.

Member Enumeration Documentation

ShaderOverrideOpacity

enum SkPaintPriv::ShaderOverrideOpacity

Enumerator
kNone_ShaderOverrideOpacity	there is no overriding shader (bitmap or image)
kOpaque_ShaderOverrideOpacity	the overriding shader is opaque
kNotOpaque_ShaderOverrideOpacity	the overriding shader may not be opaque

Definition at line 21 of file SkPaintPriv.h.

                               {
        kNone_ShaderOverrideOpacity,        //!< there is no overriding shader (bitmap or image)
        kOpaque_ShaderOverrideOpacity,      //!< the overriding shader is opaque
        kNotOpaque_ShaderOverrideOpacity,   //!< the overriding shader may not be opaque
    };

Member Function Documentation

ComputeLuminanceColor()

SkColor SkPaintPriv::ComputeLuminanceColor ( const SkPaint &  paint )

static

Definition at line 153 of file SkPaintPriv.cpp.

                                                               {
    SkColor4f c;
    if (!just_a_color(paint, &c)) {
        c = { 0.5f, 0.5f, 0.5f, 1.0f};
    }
    return c.toSkColor();
}

Flatten()

void SkPaintPriv::Flatten ( const SkPaint &  paint, SkWriteBuffer &  buffer  )

static

Serializes SkPaint into a buffer. A companion unflatten() call can reconstitute the paint at a later time.

Parameters

buffer

SkWriteBuffer receiving the flattened SkPaint data

Definition at line 261 of file SkPaintPriv.cpp.

                                                                     {
    uint8_t flatFlags = 0;
 
    if (paint.getPathEffect() ||
        paint.getShader() ||
        paint.getMaskFilter() ||
        paint.getColorFilter() ||
        paint.getImageFilter() ||
        !paint.asBlendMode()) {
        flatFlags |= kHasEffects_FlatFlag;
    }
 
    buffer.writeScalar(paint.getStrokeWidth());
    buffer.writeScalar(paint.getStrokeMiter());
    buffer.writeColor4f(paint.getColor4f());
 
    buffer.write32(pack_v68(paint, flatFlags));
 
    if (flatFlags & kHasEffects_FlatFlag) {
        buffer.writeFlattenable(paint.getPathEffect());
        buffer.writeFlattenable(paint.getShader());
        buffer.writeFlattenable(paint.getMaskFilter());
        buffer.writeFlattenable(paint.getColorFilter());
        buffer.writeFlattenable(paint.getImageFilter());
        buffer.writeFlattenable(paint.getBlender());
    }
}

Overwrites()

bool SkPaintPriv::Overwrites ( const SkPaint *  paint, ShaderOverrideOpacity  overrideOpacity  )

static

Returns true if drawing with this paint (or nullptr) will ovewrite all affected pixels.

Note: returns conservative true, meaning it may return false even though the paint might in fact overwrite its pixels.

Definition at line 83 of file SkPaintPriv.cpp.

                                                                                        {
    if (!paint) {
        // No paint means we default to SRC_OVER, so we overwrite iff our shader-override
        // is opaque, or we don't have one.
        return overrideOpacity != kNotOpaque_ShaderOverrideOpacity;
    }
 
    SrcColorOpacity opacityType = kUnknown_SrcColorOpacity;
 
    if (!changes_alpha(*paint)) {
        const unsigned paintAlpha = paint->getAlpha();
        if (0xff == paintAlpha && overrideOpacity != kNotOpaque_ShaderOverrideOpacity &&
            (!paint->getShader() || paint->getShader()->isOpaque())) {
            opacityType = kOpaque_SrcColorOpacity;
        } else if (0 == paintAlpha) {
            if (overrideOpacity == kNone_ShaderOverrideOpacity && !paint->getShader()) {
                opacityType = kTransparentBlack_SrcColorOpacity;
            } else {
                opacityType = kTransparentAlpha_SrcColorOpacity;
            }
        }
    }
 
    const auto bm = paint->asBlendMode();
    if (!bm) {
        return false;   // don't know for sure, so we play it safe and return false.
    }
    return blend_mode_is_opaque(bm.value(), opacityType);
}

RemoveColorFilter()

void SkPaintPriv::RemoveColorFilter ( SkPaint *  p, SkColorSpace *  dstCS  )

static

Definition at line 161 of file SkPaintPriv.cpp.

                                                                   {
    if (SkColorFilter* filter = p->getColorFilter()) {
        if (SkShader* shader = p->getShader()) {
            // SkColorFilterShader will modulate the shader color by paint alpha
            // before applying the filter, so we'll reset it to opaque.
            p->setShader(sk_make_sp<SkColorFilterShader>(sk_ref_sp(shader),
                                                         p->getAlphaf(),
                                                         sk_ref_sp(filter)));
            p->setAlphaf(1.0f);
        } else {
            p->setColor(filter->filterColor4f(p->getColor4f(), sk_srgb_singleton(), dstCS), dstCS);
        }
        p->setColorFilter(nullptr);
    }
}

ShouldDither()

bool SkPaintPriv::ShouldDither ( const SkPaint &  p, SkColorType  dstCT  )

static

Definition at line 113 of file SkPaintPriv.cpp.

                                                                  {
    // The paint dither flag can veto.
    if (!p.isDither()) {
        return false;
    }
 
    if (dstCT == kUnknown_SkColorType) {
        return false;
    }
 
    // We always dither 565 or 4444 when requested.
    if (dstCT == kRGB_565_SkColorType || dstCT == kARGB_4444_SkColorType) {
        return true;
    }
 
    // Otherwise, dither is only needed for non-const paints.
    return p.getImageFilter() || p.getMaskFilter() ||
           (p.getShader() && !as_SB(p.getShader())->isConstant());
}

Unflatten()

SkPaint SkPaintPriv::Unflatten ( SkReadBuffer &  buffer )

static

Populates SkPaint, typically from a serialized stream, created by calling flatten() at an earlier time.

Definition at line 289 of file SkPaintPriv.cpp.

                                                   {
    SkPaint paint;
 
    paint.setStrokeWidth(buffer.readScalar());
    paint.setStrokeMiter(buffer.readScalar());
    {
        SkColor4f color;
        buffer.readColor4f(&color);
        paint.setColor(color, sk_srgb_singleton());
    }
 
    SkSafeRange safe;
    unsigned flatFlags = unpack_v68(&paint, buffer.readUInt(), safe);
 
    if (!(flatFlags & kHasEffects_FlatFlag)) {
        // This is a simple SkPaint without any effects, so clear all the effect-related fields.
        paint.setPathEffect(nullptr);
        paint.setShader(nullptr);
        paint.setMaskFilter(nullptr);
        paint.setColorFilter(nullptr);
        paint.setImageFilter(nullptr);
    } else if (buffer.isVersionLT(SkPicturePriv::kSkBlenderInSkPaint)) {
        // This paint predates the introduction of user blend functions (via SkBlender).
        paint.setPathEffect(buffer.readPathEffect());
        paint.setShader(buffer.readShader());
        paint.setMaskFilter(buffer.readMaskFilter());
        paint.setColorFilter(buffer.readColorFilter());
        (void)buffer.read32();  // was drawLooper (now deprecated)
        paint.setImageFilter(buffer.readImageFilter());
    } else {
        paint.setPathEffect(buffer.readPathEffect());
        paint.setShader(buffer.readShader());
        paint.setMaskFilter(buffer.readMaskFilter());
        paint.setColorFilter(buffer.readColorFilter());
        paint.setImageFilter(buffer.readImageFilter());
        paint.setBlender(buffer.readBlender());
    }
 
    if (!buffer.validate(safe.ok())) {
        paint.reset();
    }
    return paint;
}

---

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

• third_party/skia/src/core/SkPaintPriv.h
• third_party/skia/src/core/SkPaintPriv.cpp