SkColorFilters Class Reference

#include <SkColorFilter.h>

Static Public Member Functions
static sk_sp< SkColorFilter >	Compose (const sk_sp< SkColorFilter > &outer, sk_sp< SkColorFilter > inner)
static sk_sp< SkColorFilter >	Blend (const SkColor4f &c, sk_sp< SkColorSpace >, SkBlendMode mode)
static sk_sp< SkColorFilter >	Blend (SkColor c, SkBlendMode mode)
static sk_sp< SkColorFilter >	Matrix (const SkColorMatrix &)
static sk_sp< SkColorFilter >	Matrix (const float rowMajor[20])
static sk_sp< SkColorFilter >	HSLAMatrix (const SkColorMatrix &)
static sk_sp< SkColorFilter >	HSLAMatrix (const float rowMajor[20])
static sk_sp< SkColorFilter >	LinearToSRGBGamma ()
static sk_sp< SkColorFilter >	SRGBToLinearGamma ()
static sk_sp< SkColorFilter >	Lerp (float t, sk_sp< SkColorFilter > dst, sk_sp< SkColorFilter > src)
static sk_sp< SkColorFilter >	Table (const uint8_t table[256])
static sk_sp< SkColorFilter >	TableARGB (const uint8_t tableA[256], const uint8_t tableR[256], const uint8_t tableG[256], const uint8_t tableB[256])
static sk_sp< SkColorFilter >	Table (sk_sp< SkColorTable > table)
static sk_sp< SkColorFilter >	Lighting (SkColor mul, SkColor add)

Detailed Description

Definition at line 90 of file SkColorFilter.h.

Member Function Documentation

Blend() [1/2]

sk_sp< SkColorFilter > SkColorFilters::Blend ( const SkColor4f &  c, sk_sp< SkColorSpace >  colorSpace, SkBlendMode  mode  )

static

Definition at line 89 of file SkBlendModeColorFilter.cpp.

                                                             {
    if (!SkIsValidMode(mode)) {
        return nullptr;
    }
 
    // First map to sRGB to simplify storage in the actual SkColorFilter instance, staying unpremul
    // until the final dst color space is known when actually filtering.
    SkColor4f srgb = map_color<kUnpremul_SkAlphaType>(color, colorSpace.get(), sk_srgb_singleton());
 
    // Next collapse some modes if possible
    float alpha = srgb.fA;
    if (SkBlendMode::kClear == mode) {
        srgb = SkColors::kTransparent;
        mode = SkBlendMode::kSrc;
    } else if (SkBlendMode::kSrcOver == mode) {
        if (0.f == alpha) {
            mode = SkBlendMode::kDst;
        } else if (1.f == alpha) {
            mode = SkBlendMode::kSrc;
        }
        // else just stay srcover
    }
 
    // Finally weed out combinations that are noops, and just return null
    if (SkBlendMode::kDst == mode ||
        (0.f == alpha && (SkBlendMode::kSrcOver == mode ||
                          SkBlendMode::kDstOver == mode ||
                          SkBlendMode::kDstOut == mode ||
                          SkBlendMode::kSrcATop == mode ||
                          SkBlendMode::kXor == mode ||
                          SkBlendMode::kDarken == mode)) ||
            (1.f == alpha && SkBlendMode::kDstIn == mode)) {
        return nullptr;
    }
 
    return sk_sp<SkColorFilter>(new SkBlendModeColorFilter(srgb, mode));
}

Blend() [2/2]

sk_sp< SkColorFilter > SkColorFilters::Blend ( SkColor  c, SkBlendMode  mode  )

static

Definition at line 129 of file SkBlendModeColorFilter.cpp.

                                                                          {
    return Blend(SkColor4f::FromColor(color), /*sRGB*/ nullptr, mode);
}

Compose()

static sk_sp< SkColorFilter > SkColorFilters::Compose ( const sk_sp< SkColorFilter > &  outer, sk_sp< SkColorFilter >  inner  )

inlinestatic

Definition at line 92 of file SkColorFilter.h.

                                                                    {
        return outer ? outer->makeComposed(std::move(inner))
                     : std::move(inner);
    }

HSLAMatrix() [1/2]

sk_sp< SkColorFilter > SkColorFilters::HSLAMatrix ( const float  rowMajor[20] )

static

Definition at line 107 of file SkMatrixColorFilter.cpp.

                                                                     {
    return MakeMatrix(array, SkMatrixColorFilter::Domain::kHSLA);
}

HSLAMatrix() [2/2]

sk_sp< SkColorFilter > SkColorFilters::HSLAMatrix ( const SkColorMatrix &  cm )

static

Definition at line 111 of file SkMatrixColorFilter.cpp.

                                                                       {
    return MakeMatrix(cm.fMat.data(), SkMatrixColorFilter::Domain::kHSLA);
}

Lerp()

sk_sp< SkColorFilter > SkColorFilters::Lerp ( float  t, sk_sp< SkColorFilter >  dst, sk_sp< SkColorFilter >  src  )

static

Definition at line 116 of file SkRuntimeColorFilter.cpp.

                                                                                  {
    using namespace SkKnownRuntimeEffects;
 
    if (!cf0 && !cf1) {
        return nullptr;
    }
    if (SkIsNaN(weight)) {
        return nullptr;
    }
 
    if (cf0 == cf1) {
        return cf0; // or cf1
    }
 
    if (weight <= 0) {
        return cf0;
    }
    if (weight >= 1) {
        return cf1;
    }
 
    const SkRuntimeEffect* lerpEffect = GetKnownRuntimeEffect(StableKey::kLerp);
 
    sk_sp<SkColorFilter> inputs[] = {cf0,cf1};
    return lerpEffect->makeColorFilter(SkData::MakeWithCopy(&weight, sizeof(weight)),
                                       inputs, std::size(inputs));
}

Lighting()

sk_sp< SkColorFilter > SkColorFilters::Lighting ( SkColor  mul, SkColor  add  )

static

Create a colorfilter that multiplies the RGB channels by one color, and then adds a second color, pinning the result for each component to [0..255]. The alpha components of the mul and add arguments are ignored.

Definition at line 26 of file SkColorMatrixFilter.cpp.

                                                                      {
    const SkColor opaqueAlphaMask = SK_ColorBLACK;
    // omit the alpha and compare only the RGB values
    if (0 == (add & ~opaqueAlphaMask)) {
        return SkColorFilters::Blend(mul | opaqueAlphaMask, SkBlendMode::kModulate);
    }
 
    SkColorMatrix matrix;
    matrix.setScale(byte_to_unit_float(SkColorGetR(mul)),
                    byte_to_unit_float(SkColorGetG(mul)),
                    byte_to_unit_float(SkColorGetB(mul)),
                    1);
    matrix.postTranslate(byte_to_unit_float(SkColorGetR(add)),
                         byte_to_unit_float(SkColorGetG(add)),
                         byte_to_unit_float(SkColorGetB(add)),
                         0);
    return SkColorFilters::Matrix(matrix);
}

LinearToSRGBGamma()

sk_sp< SkColorFilter > SkColorFilters::LinearToSRGBGamma ( )

static

Definition at line 82 of file SkColorSpaceXformColorFilter.cpp.

                                                       {
    static SkNoDestructor<SkColorSpaceXformColorFilter> gSingleton(SkColorSpace::MakeSRGBLinear(),
                                                                   SkColorSpace::MakeSRGB());
    return sk_ref_sp(gSingleton.get());
}

Matrix() [1/2]

sk_sp< SkColorFilter > SkColorFilters::Matrix ( const float  rowMajor[20] )

static

Definition at line 99 of file SkMatrixColorFilter.cpp.

                                                                 {
    return MakeMatrix(array, SkMatrixColorFilter::Domain::kRGBA);
}

Matrix() [2/2]

sk_sp< SkColorFilter > SkColorFilters::Matrix ( const SkColorMatrix &  cm )

static

Definition at line 103 of file SkMatrixColorFilter.cpp.

                                                                   {
    return MakeMatrix(cm.fMat.data(), SkMatrixColorFilter::Domain::kRGBA);
}

SRGBToLinearGamma()

sk_sp< SkColorFilter > SkColorFilters::SRGBToLinearGamma ( )

static

Definition at line 88 of file SkColorSpaceXformColorFilter.cpp.

                                                       {
    static SkNoDestructor<SkColorSpaceXformColorFilter> gSingleton(SkColorSpace::MakeSRGB(),
                                                                   SkColorSpace::MakeSRGBLinear());
    return sk_ref_sp(gSingleton.get());
}

Table() [1/2]

sk_sp< SkColorFilter > SkColorFilters::Table ( const uint8_t  table[256] )

static

Create a table colorfilter, copying the table into the filter, and applying it to all 4 components. a' = table[a]; r' = table[r]; g' = table[g]; b' = table[b]; Components are operated on in unpremultiplied space. If the incomming colors are premultiplied, they are temporarily unpremultiplied, then the table is applied, and then the result is remultiplied.

Definition at line 55 of file SkTableColorFilter.cpp.

                                                                   {
    return SkColorFilters::Table(SkColorTable::Make(table));
}

Table() [2/2]

sk_sp< SkColorFilter > SkColorFilters::Table ( sk_sp< SkColorTable >  table )

static

Create a table colorfilter that holds a ref to the shared color table.

Definition at line 66 of file SkTableColorFilter.cpp.

                                                                    {
    if (!table) {
        return nullptr;
    }
    return sk_make_sp<SkTableColorFilter>(std::move(table));
}

TableARGB()

sk_sp< SkColorFilter > SkColorFilters::TableARGB ( const uint8_t  tableA[256], const uint8_t  tableR[256], const uint8_t  tableG[256], const uint8_t  tableB[256]  )

static

Create a table colorfilter, with a different table for each component [A, R, G, B]. If a given table is NULL, then it is treated as identity, with the component left unchanged. If a table is not null, then its contents are copied into the filter.

Definition at line 59 of file SkTableColorFilter.cpp.

                                                                          {
    return SkColorFilters::Table(SkColorTable::Make(tableA, tableR, tableG, tableB));
}

---

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

• third_party/skia/include/core/SkColorFilter.h
• third_party/skia/src/effects/colorfilters/SkBlendModeColorFilter.cpp
• third_party/skia/src/effects/colorfilters/SkColorSpaceXformColorFilter.cpp
• third_party/skia/src/effects/colorfilters/SkMatrixColorFilter.cpp
• third_party/skia/src/effects/colorfilters/SkRuntimeColorFilter.cpp
• third_party/skia/src/effects/colorfilters/SkTableColorFilter.cpp
• third_party/skia/src/effects/SkColorMatrixFilter.cpp