skgpu::Swizzle Class Reference

#include <Swizzle.h>

Public Types
using	sk_is_trivially_relocatable = std::true_type

Public Member Functions
constexpr	Swizzle ()
constexpr	Swizzle (const char c[4])
constexpr	Swizzle (const Swizzle &)=default
constexpr Swizzle &	operator= (const Swizzle &that)=default
constexpr bool	operator== (const Swizzle &that) const
constexpr bool	operator!= (const Swizzle &that) const
constexpr uint16_t	asKey () const
SkString	asString () const
constexpr char	operator[] (int i) const
constexpr Swizzle	selectChannelInR (int i) const
constexpr std::array< float, 4 >	applyTo (std::array< float, 4 > color) const
template<SkAlphaType AlphaType>
constexpr SkRGBA4f< AlphaType >	applyTo (SkRGBA4f< AlphaType > color) const
void	apply (SkRasterPipeline *) const

Static Public Member Functions
static constexpr Swizzle	Concat (const Swizzle &a, const Swizzle &b)
static constexpr Swizzle	RGBA ()
static constexpr Swizzle	BGRA ()
static constexpr Swizzle	RRRA ()
static constexpr Swizzle	RGB1 ()

Friends
class	SwizzleCtorAccessor

Detailed Description

Represents a rgba swizzle. It can be converted either into a string or a eight bit int.

Definition at line 27 of file Swizzle.h.

Member Typedef Documentation

sk_is_trivially_relocatable

using skgpu::Swizzle::sk_is_trivially_relocatable = std::true_type

Definition at line 71 of file Swizzle.h.

Constructor & Destructor Documentation

Swizzle() [1/3]

constexpr skgpu::Swizzle::Swizzle ( )

inlineconstexpr

Definition at line 31 of file Swizzle.h.

: Swizzle(0x3210) {}

Swizzle() [2/3]

constexpr skgpu::Swizzle::Swizzle ( const char  c[4] )

explicitconstexpr

Definition at line 92 of file Swizzle.h.

        : fKey(static_cast<uint16_t>((CToI(c[0]) << 0) | (CToI(c[1]) << 4) | (CToI(c[2]) << 8) |
                                     (CToI(c[3]) << 12))) {}

Swizzle() [3/3]

constexpr skgpu::Swizzle::Swizzle ( const Swizzle &  )

constexprdefault

Member Function Documentation

apply()

void skgpu::Swizzle::apply

(

SkRasterPipeline *

pipeline

)

const

Definition at line 17 of file Swizzle.cpp.

                                                    {
    SkASSERT(pipeline);
    switch (fKey) {
        case Swizzle("rgba").asKey():
            return;
        case Swizzle("bgra").asKey():
            pipeline->append(SkRasterPipelineOp::swap_rb);
            return;
        case Swizzle("aaa1").asKey():
            pipeline->append(SkRasterPipelineOp::alpha_to_gray);
            return;
        case Swizzle("rgb1").asKey():
            pipeline->append(SkRasterPipelineOp::force_opaque);
            return;
        case Swizzle("a001").asKey():
            pipeline->append(SkRasterPipelineOp::alpha_to_red);
            return;
        default: {
            static_assert(sizeof(uintptr_t) >= 4 * sizeof(char));
            // Rather than allocate the 4 control bytes on the heap somewhere, just jam them right
            // into a uintptr_t context.
            uintptr_t ctx = {};
            memcpy(&ctx, this->asString().c_str(), 4 * sizeof(char));
            pipeline->append(SkRasterPipelineOp::swizzle, ctx);
            return;
        }
    }
}

applyTo() [1/2]

template<SkAlphaType AlphaType>

constexpr SkRGBA4f< AlphaType > skgpu::Swizzle::applyTo ( SkRGBA4f< AlphaType >  color ) const

inlineconstexpr

Convenience version for SkRGBA colors.

Definition at line 59 of file Swizzle.h.

                                                                           {
        std::array<float, 4> result = this->applyTo(color.array());
        return {result[0], result[1], result[2], result[3]};
    }

applyTo() [2/2]

constexpr std::array< float, 4 > skgpu::Swizzle::applyTo ( std::array< float, 4 >  color ) const

constexpr

Applies this swizzle to the input color and returns the swizzled color.

Definition at line 101 of file Swizzle.h.

                                                                            {
    uint32_t key = fKey;
    // Index of the input color that should be mapped to output r.
    size_t idx = (key & 15);
    float outR = ComponentIndexToFloat(color, idx);
    key >>= 4;
    idx = (key & 15);
    float outG = ComponentIndexToFloat(color, idx);
    key >>= 4;
    idx = (key & 15);
    float outB = ComponentIndexToFloat(color, idx);
    key >>= 4;
    idx = (key & 15);
    float outA = ComponentIndexToFloat(color, idx);
    return { outR, outG, outB, outA };
}

asKey()

constexpr uint16_t skgpu::Swizzle::asKey ( ) const

inlineconstexpr

Compact representation of the swizzle suitable for a key.

Definition at line 43 of file Swizzle.h.

{ return fKey; }

asString()

SkString skgpu::Swizzle::asString

(

)

const

4 char null terminated string consisting only of chars 'r', 'g', 'b', 'a', '0', and '1'.

Definition at line 46 of file Swizzle.cpp.

                                 {
    char swiz[5];
    uint16_t key = fKey;
    for (int i = 0; i < 4; ++i) {
        swiz[i] = IToC(key & 0xfU);
        key >>= 4;
    }
    swiz[4] = '\0';
    return SkString(swiz);
}

BGRA()

static constexpr Swizzle skgpu::Swizzle::BGRA ( )

inlinestaticconstexpr

Definition at line 67 of file Swizzle.h.

{ return Swizzle("bgra"); }

Concat()

constexpr Swizzle skgpu::Swizzle::Concat ( const Swizzle &  a, const Swizzle &  b  )

staticconstexpr

Definition at line 156 of file Swizzle.h.

                                                                    {
    uint16_t key = 0;
    for (unsigned i = 0; i < 4; ++i) {
        int idx = (b.fKey >> (4U * i)) & 0xfU;
        if (idx != CToI('0') && idx != CToI('1')) {
            SkASSERT(idx >= 0 && idx < 4);
            // Get the index value stored in a at location idx.
            idx = ((a.fKey >> (4 * idx)) & 0xfU);
        }
        key |= (idx << (4U * i));
    }
    return Swizzle(key);
}

operator!=()

constexpr bool skgpu::Swizzle::operator!= ( const Swizzle &  that ) const

inlineconstexpr

Definition at line 40 of file Swizzle.h.

{ return !(*this == that); }

operator=()

constexpr Swizzle & skgpu::Swizzle::operator= ( const Swizzle &  that )

constexprdefault

operator==()

constexpr bool skgpu::Swizzle::operator== ( const Swizzle &  that ) const

inlineconstexpr

Definition at line 39 of file Swizzle.h.

{ return fKey == that.fKey; }

operator[]()

constexpr char skgpu::Swizzle::operator[] ( int  i ) const

inlineconstexpr

Definition at line 48 of file Swizzle.h.

{ return IToC(this->channelIndex(i)); }

RGB1()

static constexpr Swizzle skgpu::Swizzle::RGB1 ( )

inlinestaticconstexpr

Definition at line 69 of file Swizzle.h.

{ return Swizzle("rgb1"); }

RGBA()

static constexpr Swizzle skgpu::Swizzle::RGBA ( )

inlinestaticconstexpr

Definition at line 66 of file Swizzle.h.

{ return Swizzle("rgba"); }

RRRA()

static constexpr Swizzle skgpu::Swizzle::RRRA ( )

inlinestaticconstexpr

Definition at line 68 of file Swizzle.h.

{ return Swizzle("rrra"); }

selectChannelInR()

constexpr Swizzle skgpu::Swizzle::selectChannelInR ( int  i ) const

constexpr

Definition at line 96 of file Swizzle.h.

                                                       {
    return Swizzle(static_cast<uint16_t>((this->channelIndex(i) << 0) | (CToI('0') << 4) |
                                         (CToI('0') << 8) | (CToI('0') << 12)));
}

Friends And Related Symbol Documentation

SwizzleCtorAccessor

friend class SwizzleCtorAccessor

friend

Definition at line 74 of file Swizzle.h.

---

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

• third_party/skia/src/gpu/Swizzle.h
• third_party/skia/src/gpu/Swizzle.cpp