#include <SkSLSwizzle.h>

Inheritance diagram for SkSL::Swizzle:

Public Types
using	Component = SwizzleComponent::Type

Public Types inherited from SkSL::Expression
enum class	ComparisonResult { kUnknown = -1 , kNotEqual , kEqual }

using	Kind = ExpressionKind

Public Member Functions
	Swizzle (const Context &context, Position pos, std::unique_ptr< Expression > base, const ComponentArray &components)

std::unique_ptr< Expression > &	base ()

const std::unique_ptr< Expression > &	base () const

const ComponentArray &	components () const

std::unique_ptr< Expression >	clone (Position pos) const override

std::string	description (OperatorPrecedence) const override

Public Member Functions inherited from SkSL::Expression
	Expression (Position pos, Kind kind, const Type *type)

Kind	kind () const

virtual const Type &	type () const

bool	isAnyConstructor () const

bool	isIntLiteral () const

bool	isFloatLiteral () const

bool	isBoolLiteral () const

AnyConstructor &	asAnyConstructor ()

const AnyConstructor &	asAnyConstructor () const

bool	isIncomplete (const Context &context) const

virtual ComparisonResult	compareConstant (const Expression &other) const

CoercionCost	coercionCost (const Type &target) const

virtual bool	supportsConstantValues () const

virtual std::optional< double >	getConstantValue (int n) const

std::unique_ptr< Expression >	clone () const

std::string	description () const final

Public Member Functions inherited from SkSL::IRNode
virtual	~IRNode ()

	IRNode (const IRNode &)=delete

IRNode &	operator= (const IRNode &)=delete

Position	position () const

void	setPosition (Position p)

template<typename T >
bool	is () const

template<typename T >
const T &	as () const

template<typename T >
T &	as ()

Static Public Member Functions
static std::unique_ptr< Expression >	Convert (const Context &context, Position pos, Position maskPos, std::unique_ptr< Expression > base, ComponentArray inComponents)

static std::unique_ptr< Expression >	Convert (const Context &context, Position pos, Position maskPos, std::unique_ptr< Expression > base, std::string_view maskString)

static std::unique_ptr< Expression >	Make (const Context &context, Position pos, std::unique_ptr< Expression > expr, ComponentArray inComponents)

static std::string	MaskString (const ComponentArray &inComponents)

Static Public Member Functions inherited from SkSL::Poolable
static void *	operator new (const size_t size)

static void	operator delete (void *ptr)

Static Public Attributes
static constexpr Kind	kIRNodeKind = Kind::kSwizzle

Additional Inherited Members
Public Attributes inherited from SkSL::IRNode
Position	fPosition

Protected Member Functions inherited from SkSL::IRNode
	IRNode (Position position, int kind)

Protected Attributes inherited from SkSL::IRNode
int	fKind

Detailed Description

Represents a vector swizzle operation such as 'float3(1, 2, 3).zyx'.

Definition at line 45 of file SkSLSwizzle.h.

Member Typedef Documentation

◆ Component

using SkSL::Swizzle::Component = SwizzleComponent::Type

Definition at line 49 of file SkSLSwizzle.h.

Constructor & Destructor Documentation

◆ Swizzle()

SkSL::Swizzle::Swizzle	(	const Context &	context,
		Position	pos,
		std::unique_ptr< Expression >	base,
		const ComponentArray &	components
	)

inline

Definition at line 51 of file SkSLSwizzle.h.

            : INHERITED(pos, kIRNodeKind,
                        &base->type().componentType().toCompound(context, components.size(), 1))
            , fBase(std::move(base))
            , fComponents(components) {
        SkASSERT(this->components().size() >= 1 && this->components().size() <= 4);
    }

Member Function Documentation

◆ base() [1/2]

std::unique_ptr< Expression > & SkSL::Swizzle::base ( )

inline

Definition at line 82 of file SkSLSwizzle.h.

                                      {
        return fBase;
    }

◆ base() [2/2]

const std::unique_ptr< Expression > & SkSL::Swizzle::base ( ) const

inline

Definition at line 86 of file SkSLSwizzle.h.

                                                  {
        return fBase;
    }

◆ clone()

std::unique_ptr< Expression > SkSL::Swizzle::clone ( Position pos ) const

inlineoverridevirtual

Implements SkSL::Expression.

Definition at line 94 of file SkSLSwizzle.h.

                                                                 {
        return std::unique_ptr<Expression>(new Swizzle(pos, &this->type(), this->base()->clone(),
                                                       this->components()));
    }

◆ components()

const ComponentArray & SkSL::Swizzle::components ( ) const

inline

Definition at line 90 of file SkSLSwizzle.h.

                                             {
        return fComponents;
    }

◆ Convert() [1/2]

std::unique_ptr< Expression > SkSL::Swizzle::Convert	(	const Context &	context,
		Position	pos,
		Position	maskPos,
		std::unique_ptr< Expression >	base,
		ComponentArray	inComponents
	)

static

Definition at line 287 of file SkSLSwizzle.cpp.

                                                                          {
    if (inComponents.size() > 4) {
        context.fErrors->error(Position::Range(maskPos.startOffset() + 4,
                                               maskPos.endOffset()),
                               "too many components in swizzle mask");
        return nullptr;
    }
 
    if (!validate_swizzle_domain(inComponents)) {
        context.fErrors->error(maskPos, "invalid swizzle mask '" + MaskString(inComponents) + "'");
        return nullptr;
    }
 
    const Type& baseType = base->type().scalarTypeForLiteral();
 
    if (!baseType.isVector() && !baseType.isScalar()) {
        context.fErrors->error(pos, "cannot swizzle value of type '" +
                                    baseType.displayName() + "'");
        return nullptr;
    }
 
    ComponentArray maskComponents;
    bool foundXYZW = false;
    for (int i = 0; i < inComponents.size(); ++i) {
        switch (inComponents[i]) {
            case SwizzleComponent::ZERO:
            case SwizzleComponent::ONE:
                // Skip over constant fields for now.
                break;
            case SwizzleComponent::X:
            case SwizzleComponent::R:
            case SwizzleComponent::S:
            case SwizzleComponent::UL:
                foundXYZW = true;
                maskComponents.push_back(SwizzleComponent::X);
                break;
            case SwizzleComponent::Y:
            case SwizzleComponent::G:
            case SwizzleComponent::T:
            case SwizzleComponent::UT:
                foundXYZW = true;
                if (baseType.columns() >= 2) {
                    maskComponents.push_back(SwizzleComponent::Y);
                    break;
                }
                [[fallthrough]];
            case SwizzleComponent::Z:
            case SwizzleComponent::B:
            case SwizzleComponent::P:
            case SwizzleComponent::UR:
                foundXYZW = true;
                if (baseType.columns() >= 3) {
                    maskComponents.push_back(SwizzleComponent::Z);
                    break;
                }
                [[fallthrough]];
            case SwizzleComponent::W:
            case SwizzleComponent::A:
            case SwizzleComponent::Q:
            case SwizzleComponent::UB:
                foundXYZW = true;
                if (baseType.columns() >= 4) {
                    maskComponents.push_back(SwizzleComponent::W);
                    break;
                }
                [[fallthrough]];
            default:
                // The swizzle component references a field that doesn't exist in the base type.
                context.fErrors->error(Position::Range(maskPos.startOffset() + i,
                                                       maskPos.startOffset() + i + 1),
                                       String::printf("invalid swizzle component '%c'",
                                                      mask_char(inComponents[i])));
                return nullptr;
        }
    }
 
    if (!foundXYZW) {
        context.fErrors->error(maskPos, "swizzle must refer to base expression");
        return nullptr;
    }
 
    // Coerce literals in expressions such as `(12345).xxx` to their actual type.
    base = baseType.coerceExpression(std::move(base), context);
    if (!base) {
        return nullptr;
    }
 
    // First, we need a vector expression that is the non-constant portion of the swizzle, packed:
    //   scalar.xxx  -> type3(scalar)
    //   scalar.x0x0 -> type2(scalar)
    //   vector.zyx  -> vector.zyx
    //   vector.x0y0 -> vector.xy
    std::unique_ptr<Expression> expr = Swizzle::Make(context, pos, std::move(base), maskComponents);
 
    // If we have processed the entire swizzle, we're done.
    if (maskComponents.size() == inComponents.size()) {
        return expr;
    }
 
    // Now we create a constructor that has the correct number of elements for the final swizzle,
    // with all fields at the start. It's not finished yet; constants we need will be added below.
    //   scalar.x0x0 -> type4(type2(x), ...)
    //   vector.y111 -> type4(vector.y, ...)
    //   vector.z10x -> type4(vector.zx, ...)
    //
    // The constructor will have at most three arguments: { base expr, constant 0, constant 1 }
    ExpressionArray constructorArgs;
    constructorArgs.reserve_exact(3);
    constructorArgs.push_back(std::move(expr));
 
    // Apply another swizzle to shuffle the constants into the correct place. Any constant values we
    // need are also tacked on to the end of the constructor.
    //   scalar.x0x0 -> type4(type2(x), 0).xyxy
    //   vector.y111 -> type2(vector.y, 1).xyyy
    //   vector.z10x -> type4(vector.zx, 1, 0).xzwy
    const Type* scalarType = &baseType.componentType();
    ComponentArray swizzleComponents;
    int maskFieldIdx = 0;
    int constantFieldIdx = maskComponents.size();
    int constantZeroIdx = -1, constantOneIdx = -1;
 
    for (int i = 0; i < inComponents.size(); i++) {
        switch (inComponents[i]) {
            case SwizzleComponent::ZERO:
                if (constantZeroIdx == -1) {
                    // Synthesize a '0' argument at the end of the constructor.
                    constructorArgs.push_back(Literal::Make(pos, /*value=*/0, scalarType));
                    constantZeroIdx = constantFieldIdx++;
                }
                swizzleComponents.push_back(constantZeroIdx);
                break;
            case SwizzleComponent::ONE:
                if (constantOneIdx == -1) {
                    // Synthesize a '1' argument at the end of the constructor.
                    constructorArgs.push_back(Literal::Make(pos, /*value=*/1, scalarType));
                    constantOneIdx = constantFieldIdx++;
                }
                swizzleComponents.push_back(constantOneIdx);
                break;
            default:
                // The non-constant fields are already in the expected order.
                swizzleComponents.push_back(maskFieldIdx++);
                break;
        }
    }
 
    expr = ConstructorCompound::Make(context, pos,
                                     scalarType->toCompound(context, constantFieldIdx, /*rows=*/1),
                                     std::move(constructorArgs));
 
    // Create (and potentially optimize-away) the resulting swizzle-expression.
    return Swizzle::Make(context, pos, std::move(expr), swizzleComponents);
}

◆ Convert() [2/2]

std::unique_ptr< Expression > SkSL::Swizzle::Convert	(	const Context &	context,
		Position	pos,
		Position	maskPos,
		std::unique_ptr< Expression >	base,
		std::string_view	maskString
	)

static

Definition at line 245 of file SkSLSwizzle.cpp.

                                                                        {
    ComponentArray components;
    for (size_t i = 0; i < maskString.length(); ++i) {
        char field = maskString[i];
        switch (field) {
            case '0': components.push_back(SwizzleComponent::ZERO); break;
            case '1': components.push_back(SwizzleComponent::ONE);  break;
            case 'x': components.push_back(SwizzleComponent::X);    break;
            case 'r': components.push_back(SwizzleComponent::R);    break;
            case 's': components.push_back(SwizzleComponent::S);    break;
            case 'L': components.push_back(SwizzleComponent::UL);   break;
            case 'y': components.push_back(SwizzleComponent::Y);    break;
            case 'g': components.push_back(SwizzleComponent::G);    break;
            case 't': components.push_back(SwizzleComponent::T);    break;
            case 'T': components.push_back(SwizzleComponent::UT);   break;
            case 'z': components.push_back(SwizzleComponent::Z);    break;
            case 'b': components.push_back(SwizzleComponent::B);    break;
            case 'p': components.push_back(SwizzleComponent::P);    break;
            case 'R': components.push_back(SwizzleComponent::UR);   break;
            case 'w': components.push_back(SwizzleComponent::W);    break;
            case 'a': components.push_back(SwizzleComponent::A);    break;
            case 'q': components.push_back(SwizzleComponent::Q);    break;
            case 'B': components.push_back(SwizzleComponent::UB);   break;
            default:
                context.fErrors->error(Position::Range(maskPos.startOffset() + i,
                                                       maskPos.startOffset() + i + 1),
                                       String::printf("invalid swizzle component '%c'", field));
                return nullptr;
        }
    }
    return Convert(context, pos, maskPos, std::move(base), std::move(components));
}

◆ description()

std::string SkSL::Swizzle::description ( OperatorPrecedence ) const

overridevirtual

Implements SkSL::Expression.

Definition at line 537 of file SkSLSwizzle.cpp.

                                                       {
    return this->base()->description(OperatorPrecedence::kPostfix) + "." +
           MaskString(this->components());
}

◆ Make()

std::unique_ptr< Expression > SkSL::Swizzle::Make	(	const Context &	context,
		Position	pos,
		std::unique_ptr< Expression >	expr,
		ComponentArray	inComponents
	)

static

Definition at line 445 of file SkSLSwizzle.cpp.

                                                                     {
    const Type& exprType = expr->type();
    SkASSERTF(exprType.isVector() || exprType.isScalar(),
              "cannot swizzle type '%s'", exprType.description().c_str());
    SkASSERT(components.size() >= 1 && components.size() <= 4);
 
    // Confirm that the component array only contains X/Y/Z/W. (Call MakeWith01 if you want support
    // for ZERO and ONE. Once initial IR generation is complete, no swizzles should have zeros or
    // ones in them.)
    SkASSERT(std::all_of(components.begin(), components.end(), [](int8_t component) {
        return component >= SwizzleComponent::X &&
               component <= SwizzleComponent::W;
    }));
 
    // SkSL supports splatting a scalar via `scalar.xxxx`, but not all versions of GLSL allow this.
    // Replace swizzles with equivalent splat constructors (`scalar.xxx` --> `half3(value)`).
    if (exprType.isScalar()) {
        return ConstructorSplat::Make(context, pos,
                                      exprType.toCompound(context, components.size(), /*rows=*/1),
                                      std::move(expr));
    }
 
    // Detect identity swizzles like `color.rgba` and optimize it away.
    if (components.size() == exprType.columns()) {
        bool identity = true;
        for (int i = 0; i < components.size(); ++i) {
            if (components[i] != i) {
                identity = false;
                break;
            }
        }
        if (identity) {
            expr->fPosition = pos;
            return expr;
        }
    }
 
    // Optimize swizzles of swizzles, e.g. replace `foo.argb.rggg` with `foo.arrr`.
    if (expr->is<Swizzle>()) {
        Swizzle& base = expr->as<Swizzle>();
        ComponentArray combined;
        for (int8_t c : components) {
            combined.push_back(base.components()[c]);
        }
 
        // It may actually be possible to further simplify this swizzle. Go again.
        // (e.g. `color.abgr.abgr` --> `color.rgba` --> `color`.)
        return Swizzle::Make(context, pos, std::move(base.base()), combined);
    }
 
    // If we are swizzling a constant expression, we can use its value instead here (so that
    // swizzles like `colorWhite.x` can be simplified to `1`).
    const Expression* value = ConstantFolder::GetConstantValueForVariable(*expr);
 
    // `half4(scalar).zyy` can be optimized to `half3(scalar)`, and `half3(scalar).y` can be
    // optimized to just `scalar`. The swizzle components don't actually matter, as every field
    // in a splat constructor holds the same value.
    if (value->is<ConstructorSplat>()) {
        const ConstructorSplat& splat = value->as<ConstructorSplat>();
        return ConstructorSplat::Make(
                context, pos,
                splat.type().componentType().toCompound(context, components.size(), /*rows=*/1),
                splat.argument()->clone());
    }
 
    // Swizzles on casts, like `half4(myFloat4).zyy`, can optimize to `half3(myFloat4.zyy)`.
    if (value->is<ConstructorCompoundCast>()) {
        const ConstructorCompoundCast& cast = value->as<ConstructorCompoundCast>();
        const Type& castType = cast.type().componentType().toCompound(context, components.size(),
                                                                      /*rows=*/1);
        std::unique_ptr<Expression> swizzled = Swizzle::Make(context, pos, cast.argument()->clone(),
                                                             std::move(components));
        return (castType.columns() > 1)
                       ? ConstructorCompoundCast::Make(context, pos, castType, std::move(swizzled))
                       : ConstructorScalarCast::Make(context, pos, castType, std::move(swizzled));
    }
 
    // Swizzles on compound constructors, like `half4(1, 2, 3, 4).yw`, can become `half2(2, 4)`.
    if (value->is<ConstructorCompound>()) {
        const ConstructorCompound& ctor = value->as<ConstructorCompound>();
        if (auto replacement = optimize_constructor_swizzle(context, pos, ctor, components)) {
            return replacement;
        }
    }
 
    // The swizzle could not be simplified, so apply the requested swizzle to the base expression.
    return std::make_unique<Swizzle>(context, pos, std::move(expr), components);
}

◆ MaskString()

std::string SkSL::Swizzle::MaskString ( const ComponentArray & inComponents )

static

Definition at line 111 of file SkSLSwizzle.cpp.

                                                              {
    std::string result;
    for (int8_t component : components) {
        result += mask_char(component);
    }
    return result;
}

Member Data Documentation

◆ kIRNodeKind

constexpr Kind SkSL::Swizzle::kIRNodeKind = Kind::kSwizzle

inlinestaticconstexpr

Definition at line 47 of file SkSLSwizzle.h.

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

third_party/skia/src/sksl/ir/SkSLSwizzle.h
third_party/skia/src/sksl/ir/SkSLSwizzle.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Component

Constructor & Destructor Documentation

◆ Swizzle()

Member Function Documentation

◆ base() [1/2]

◆ base() [2/2]

◆ clone()

◆ components()

◆ Convert() [1/2]

◆ Convert() [2/2]

◆ description()

◆ Make()

◆ MaskString()

Member Data Documentation

◆ kIRNodeKind