SkPaintPriv.cpp File Reference

#include "src/core/SkPaintPriv.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkBlender.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorType.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkShader.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkPicturePriv.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkSafeRange.h"
#include "src/core/SkWriteBuffer.h"
#include "src/effects/colorfilters/SkColorFilterBase.h"
#include "src/shaders/SkColorFilterShader.h"
#include "src/shaders/SkShaderBase.h"
#include <cstdint>
#include <optional>

Go to the source code of this file.

Macros
#define	ASSERT_FITS_IN(value, bitcount)

Enumerations
enum	SrcColorOpacity { kOpaque_SrcColorOpacity = 0 , kTransparentBlack_SrcColorOpacity = 1 , kTransparentAlpha_SrcColorOpacity = 2 , kUnknown_SrcColorOpacity = 3 }
enum	FlatFlags { kHasTypeface_FlatFlag = 0x1 , kHasEffects_FlatFlag = 0x2 , kFlatFlagMask = 0x3 }

Functions
static bool	changes_alpha (const SkPaint &paint)
static bool	blend_mode_is_opaque (SkBlendMode mode, SrcColorOpacity opacityType)
static bool	just_a_color (const SkPaint &paint, SkColor4f *color)
template<typename T >
uint32_t	shift_bits (T value, unsigned shift, unsigned bits)
static uint32_t	pack_v68 (const SkPaint &paint, unsigned flatFlags)
static uint32_t	unpack_v68 (SkPaint *paint, uint32_t packed, SkSafeRange &safe)

Variables
constexpr uint8_t	CUSTOM_BLEND_MODE_SENTINEL = 0xFF

Macro Definition Documentation

ASSERT_FITS_IN

#define ASSERT_FITS_IN	(		value,
			bitcount
	)

Definition at line 185 of file SkPaintPriv.cpp.

Enumeration Type Documentation

FlatFlags

enum FlatFlags

Enumerator
kHasTypeface_FlatFlag
kHasEffects_FlatFlag
kFlatFlagMask

Definition at line 188 of file SkPaintPriv.cpp.

               {
    kHasTypeface_FlatFlag = 0x1,
    kHasEffects_FlatFlag  = 0x2,
 
    kFlatFlagMask         = 0x3,
};

SrcColorOpacity

enum SrcColorOpacity

Enumerator
kOpaque_SrcColorOpacity
kTransparentBlack_SrcColorOpacity
kTransparentAlpha_SrcColorOpacity
kUnknown_SrcColorOpacity

Definition at line 41 of file SkPaintPriv.cpp.

                     {
    // The src color is known to be opaque (alpha == 255)
    kOpaque_SrcColorOpacity = 0,
    // The src color is known to be fully transparent (color == 0)
    kTransparentBlack_SrcColorOpacity = 1,
    // The src alpha is known to be fully transparent (alpha == 0)
    kTransparentAlpha_SrcColorOpacity = 2,
    // The src color opacity is unknown
    kUnknown_SrcColorOpacity = 3
};

Function Documentation

blend_mode_is_opaque()

static bool blend_mode_is_opaque ( SkBlendMode  mode, SrcColorOpacity  opacityType  )

static

Definition at line 52 of file SkPaintPriv.cpp.

                                                                                {
    SkBlendModeCoeff src, dst;
    if (!SkBlendMode_AsCoeff(mode, &src, &dst)) {
        return false;
    }
 
    switch (src) {
        case SkBlendModeCoeff::kDA:
        case SkBlendModeCoeff::kDC:
        case SkBlendModeCoeff::kIDA:
        case SkBlendModeCoeff::kIDC:
            return false;
        default:
            break;
    }
 
    switch (dst) {
        case SkBlendModeCoeff::kZero:
            return true;
        case SkBlendModeCoeff::kISA:
            return kOpaque_SrcColorOpacity == opacityType;
        case SkBlendModeCoeff::kSA:
            return kTransparentBlack_SrcColorOpacity == opacityType ||
                   kTransparentAlpha_SrcColorOpacity == opacityType;
        case SkBlendModeCoeff::kSC:
            return kTransparentBlack_SrcColorOpacity == opacityType;
        default:
            return false;
    }
}

changes_alpha()

static bool changes_alpha ( const SkPaint &  paint )

static

Definition at line 36 of file SkPaintPriv.cpp.

                                                {
    SkColorFilter* cf = paint.getColorFilter();
    return cf && !as_CFB(cf)->isAlphaUnchanged();
}

just_a_color()

static bool just_a_color ( const SkPaint &  paint, SkColor4f *  color  )

static

Definition at line 135 of file SkPaintPriv.cpp.

                                                                 {
    SkColor4f c = paint.getColor4f();
 
    const auto* shader = as_SB(paint.getShader());
    if (shader && !shader->asLuminanceColor(&c)) {
        return false;
    }
    if (paint.getColorFilter()) {
        // TODO: This colorspace is meaningless, replace it with something else
        SkColorSpace* cs = nullptr;
        c = paint.getColorFilter()->filterColor4f(c, cs, cs);
    }
    if (color) {
        *color = c;
    }
    return true;
}

pack_v68()

static uint32_t pack_v68 ( const SkPaint &  paint, unsigned  flatFlags  )

static

Definition at line 217 of file SkPaintPriv.cpp.

                                                                   {
    uint32_t packed = 0;
    const auto bm = paint.asBlendMode();
    const unsigned mode = bm ? static_cast<unsigned>(bm.value())
                             : CUSTOM_BLEND_MODE_SENTINEL;
 
    packed |= shift_bits(((unsigned)paint.isDither() << 1) |
                          (unsigned)paint.isAntiAlias(), 0, 8);
    packed |= shift_bits(mode,                      8, 8);
    packed |= shift_bits(paint.getStrokeCap(),     16, 2);
    packed |= shift_bits(paint.getStrokeJoin(),    18, 2);
    packed |= shift_bits(paint.getStyle(),         20, 2);
    packed |= shift_bits(0,                        22, 2); // was filterquality
    packed |= shift_bits(flatFlags,                24, 8);
    return packed;
}

shift_bits()

template<typename T >

uint32_t shift_bits	(	T	value,
		unsigned	shift,
		unsigned	bits
	)

Definition at line 198 of file SkPaintPriv.cpp.

                                                                                  {
    SkASSERT(shift + bits <= 32);
    uint32_t v = static_cast<uint32_t>(value);
    ASSERT_FITS_IN(v, bits);
    return v << shift;
}

unpack_v68()

static uint32_t unpack_v68 ( SkPaint *  paint, uint32_t  packed, SkSafeRange &  safe  )

static

Definition at line 234 of file SkPaintPriv.cpp.

                                                                               {
    paint->setAntiAlias((packed & 1) != 0);
    paint->setDither((packed & 2) != 0);
    packed >>= 8;
    {
        unsigned mode = packed & 0xFF;
        if (mode != CUSTOM_BLEND_MODE_SENTINEL) { // sentinel for custom blender
            paint->setBlendMode(safe.checkLE(mode, SkBlendMode::kLastMode));
        }
        // else we will unflatten the custom blender
    }
    packed >>= 8;
    paint->setStrokeCap(safe.checkLE(packed & 0x3, SkPaint::kLast_Cap));
    packed >>= 2;
    paint->setStrokeJoin(safe.checkLE(packed & 0x3, SkPaint::kLast_Join));
    packed >>= 2;
    paint->setStyle(safe.checkLE(packed & 0x3, SkPaint::kStrokeAndFill_Style));
    packed >>= 2;
    // skip the (now ignored) filterquality bits
    packed >>= 2;
 
    return packed;
}

Variable Documentation

CUSTOM_BLEND_MODE_SENTINEL

constexpr uint8_t CUSTOM_BLEND_MODE_SENTINEL = 0xFF

constexpr

Definition at line 205 of file SkPaintPriv.cpp.