#include <SkSLType.h>

Inheritance diagram for SkSL::Type:

Public Types
enum class	TypeKind : int8_t { kArray , kAtomic , kGeneric , kLiteral , kMatrix , kOther , kSampler , kSeparateSampler , kScalar , kStruct , kTexture , kVector , kVoid , kColorFilter , kShader , kBlender }

enum class	NumberKind : int8_t { kFloat , kSigned , kUnsigned , kBoolean , kNonnumeric }

enum class	TextureAccess : int8_t { kSample , kRead , kWrite , kReadWrite }

Public Types inherited from SkSL::Symbol
using	Kind = SymbolKind

Public Member Functions
	Type (const Type &other)=delete

std::string	getArrayName (int arraySize) const

template<typename T >
bool	is () const

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

template<typename T >
T &	as ()

const Type *	clone (const Context &context, SymbolTable *symbolTable) const

virtual bool	isBuiltin () const

std::string	displayName () const

std::string	description () const override

bool	isAllowedInES2 (const Context &context) const

virtual bool	isAllowedInES2 () const

virtual bool	isAllowedInUniform (Position *errorPosition=nullptr) const

virtual const Type &	resolve () const

bool	matches (const Type &other) const

const char *	abbreviatedName () const

TypeKind	typeKind () const

virtual NumberKind	numberKind () const

bool	isBoolean () const

bool	isNumber () const

bool	isFloat () const

bool	isSigned () const

bool	isUnsigned () const

bool	isInteger () const

bool	isOpaque () const

bool	isStorageTexture () const

virtual int	priority () const

bool	canCoerceTo (const Type &other, bool allowNarrowing) const

CoercionCost	coercionCost (const Type &other) const

virtual const Type &	componentType () const

const Type &	columnType (const Context &context) const

virtual const Type &	textureType () const

virtual int	columns () const

virtual int	rows () const

virtual double	minimumValue () const

virtual double	maximumValue () const

virtual size_t	slotCount () const

virtual const Type &	slotType (size_t) const

virtual SkSpan< const Field >	fields () const

virtual SkSpan< const Type *const >	coercibleTypes () const

virtual SpvDim_	dimensions () const

virtual bool	isDepth () const

virtual bool	isArrayedTexture () const

bool	isVoid () const

bool	isGeneric () const

bool	isSampler () const

bool	isAtomic () const

virtual bool	isScalar () const

virtual bool	isLiteral () const

virtual const Type &	scalarTypeForLiteral () const

virtual bool	isVector () const

virtual bool	isMatrix () const

virtual bool	isArray () const

virtual bool	isUnsizedArray () const

virtual bool	isStruct () const

virtual bool	isInterfaceBlock () const

bool	isEffectChild () const

virtual bool	isMultisampled () const

virtual TextureAccess	textureAccess () const

bool	hasPrecision () const

bool	highPrecision () const

virtual int	bitWidth () const

virtual bool	isOrContainsArray () const

virtual bool	isOrContainsUnsizedArray () const

virtual bool	isOrContainsAtomic () const

const Type &	toCompound (const Context &context, int columns, int rows) const

const Type *	applyQualifiers (const Context &context, ModifierFlags *modifierFlags, Position pos) const

std::unique_ptr< Expression >	coerceExpression (std::unique_ptr< Expression > expr, const Context &context) const

bool	checkForOutOfRangeLiteral (const Context &context, const Expression &expr) const

bool	checkForOutOfRangeLiteral (const Context &context, double value, Position pos) const

bool	checkIfUsableInArray (const Context &context, Position arrayPos) const

SKSL_INT	convertArraySize (const Context &context, Position arrayPos, std::unique_ptr< Expression > size) const

SKSL_INT	convertArraySize (const Context &context, Position arrayPos, Position sizePos, SKSL_INT size) const

Public Member Functions inherited from SkSL::Symbol
	Symbol (Position pos, Kind kind, std::string_view name, const Type *type=nullptr)

	~Symbol () override

std::unique_ptr< Expression >	instantiate (const Context &context, Position pos) const

const Type &	type () const

Kind	kind () const

std::string_view	name () const

void	setName (std::string_view newName)

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< Type >	MakeArrayType (const Context &context, std::string_view name, const Type &componentType, int columns)

static std::unique_ptr< Type >	MakeAliasType (std::string_view name, const Type &targetType)

static std::unique_ptr< Type >	MakeGenericType (const char name, SkSpan< const Type const > types, const Type *slotType)

static std::unique_ptr< Type >	MakeLiteralType (const char *name, const Type &scalarType, int8_t priority)

static std::unique_ptr< Type >	MakeMatrixType (std::string_view name, const char *abbrev, const Type &componentType, int columns, int8_t rows)

static std::unique_ptr< Type >	MakeSamplerType (const char *name, const Type &textureType)

static std::unique_ptr< Type >	MakeScalarType (std::string_view name, const char *abbrev, Type::NumberKind numberKind, int8_t priority, int8_t bitWidth)

static std::unique_ptr< Type >	MakeSpecialType (const char name, const char abbrev, Type::TypeKind typeKind)

static std::unique_ptr< Type >	MakeStructType (const Context &context, Position pos, std::string_view name, skia_private::TArray< Field > fields, bool interfaceBlock=false)

static std::unique_ptr< Type >	MakeTextureType (const char *name, SpvDim_ dimensions, bool isDepth, bool isArrayedTexture, bool isMultisampled, TextureAccess textureAccess)

static std::unique_ptr< Type >	MakeVectorType (std::string_view name, const char *abbrev, const Type &componentType, int columns)

static std::unique_ptr< Type >	MakeAtomicType (std::string_view name, const char *abbrev)

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::kType

static constexpr int	kMaxAbbrevLength = 3

static constexpr int	kUnsizedArray = -1

Protected Member Functions
	Type (std::string_view name, const char *abbrev, TypeKind kind, Position pos=Position())

const Type *	applyPrecisionQualifiers (const Context &context, ModifierFlags *modifierFlags, Position pos) const

const Type *	applyAccessQualifiers (const Context &context, ModifierFlags *modifierFlags, Position pos) const

bool	isInRootSymbolTable () const

virtual int	structNestingDepth () const

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

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

Protected Attributes inherited from SkSL::IRNode
int	fKind

Detailed Description

Represents a type, such as int or float4.

Definition at line 94 of file SkSLType.h.

Member Enumeration Documentation

◆ NumberKind

enum class SkSL::Type::NumberKind : int8_t

strong

Enumerator
kFloat
kSigned
kUnsigned
kBoolean
kNonnumeric

Definition at line 122 of file SkSLType.h.

                          : int8_t {
        kFloat,
        kSigned,
        kUnsigned,
        kBoolean,
        kNonnumeric
    };

◆ TextureAccess

enum class SkSL::Type::TextureAccess : int8_t

strong

Enumerator
kSample
kRead
kWrite
kReadWrite

Definition at line 130 of file SkSLType.h.

                             : int8_t {
        kSample,  // `kSample` access level allows both sampling and reading
        kRead,
        kWrite,
        kReadWrite,
    };

◆ TypeKind

enum class SkSL::Type::TypeKind : int8_t

strong

Enumerator
kArray
kAtomic
kGeneric
kLiteral
kMatrix
kOther
kSampler
kSeparateSampler
kScalar
kStruct
kTexture
kVector
kVoid
kColorFilter
kShader
kBlender

Definition at line 101 of file SkSLType.h.

                        : int8_t {
        kArray,
        kAtomic,
        kGeneric,
        kLiteral,
        kMatrix,
        kOther,
        kSampler,
        kSeparateSampler,
        kScalar,
        kStruct,
        kTexture,
        kVector,
        kVoid,
 
        // Types that represent stages in the Skia pipeline
        kColorFilter,
        kShader,
        kBlender,
    };

Constructor & Destructor Documentation

◆ Type() [1/2]

SkSL::Type::Type ( const Type & other )

delete

◆ Type() [2/2]

SkSL::Type::Type	(	std::string_view	name,
		const char *	abbrev,
		TypeKind	kind,
		Position	pos = `Position()`
	)

inlineprotected

Definition at line 639 of file SkSLType.h.

            : INHERITED(pos, kIRNodeKind, name)
            , fTypeKind(kind) {
        SkASSERT(strlen(abbrev) <= kMaxAbbrevLength);
        strcpy(fAbbreviatedName, abbrev);
    }

Member Function Documentation

◆ abbreviatedName()

const char * SkSL::Type::abbreviatedName ( ) const

inline

Returns an abbreviated name of the type, meant for name-mangling. (e.g. float4x4 -> f44)

Definition at line 276 of file SkSLType.h.

                                        {
        return fAbbreviatedName;
    }

◆ applyAccessQualifiers()

const Type * SkSL::Type::applyAccessQualifiers	(	const Context &	context,
		ModifierFlags *	modifierFlags,
		Position	pos
	)		const

protected

Definition at line 1014 of file SkSLType.cpp.

                                                            {
    ModifierFlags accessQualifiers = *modifierFlags & (ModifierFlag::kReadOnly |
                                                       ModifierFlag::kWriteOnly);
 
    // We're going to return a whole new type, so the modifier bits must be cleared out.
    *modifierFlags &= ~(ModifierFlag::kReadOnly |
                        ModifierFlag::kWriteOnly);
 
    if (this->matches(*context.fTypes.fTexture2D)) {
        // We require all texture2Ds to be qualified with `readonly` or `writeonly`.
        // (Read-write textures are not yet supported in WGSL.)
        if (accessQualifiers == ModifierFlag::kReadOnly) {
            return context.fTypes.fReadOnlyTexture2D.get();
        }
        if (accessQualifiers == ModifierFlag::kWriteOnly) {
            return context.fTypes.fWriteOnlyTexture2D.get();
        }
        context.fErrors->error(
                pos,
                accessQualifiers
                        ? "'readonly' and 'writeonly' qualifiers cannot be combined"
                        : "'texture2D' requires a 'readonly' or 'writeonly' access qualifier");
        return this;
    }
 
    if (accessQualifiers) {
        context.fErrors->error(pos, "type '" + this->displayName() + "' does not support "
                                    "qualifier '" + accessQualifiers.description() + "'");
    }
 
    return this;
}

◆ applyPrecisionQualifiers()

const Type * SkSL::Type::applyPrecisionQualifiers	(	const Context &	context,
		ModifierFlags *	modifierFlags,
		Position	pos
	)		const

protected

Definition at line 945 of file SkSLType.cpp.

                                                               {
    ModifierFlags precisionQualifiers = *modifierFlags & (ModifierFlag::kHighp |
                                                          ModifierFlag::kMediump |
                                                          ModifierFlag::kLowp);
    if (precisionQualifiers == ModifierFlag::kNone) {
        // No precision qualifiers here. Return the type as-is.
        return this;
    }
 
    if (!ProgramConfig::IsRuntimeEffect(context.fConfig->fKind)) {
        // We want to discourage precision modifiers internally. Instead, use the type that
        // corresponds to the precision you need. (e.g. half vs float, short vs int)
        context.fErrors->error(pos, "precision qualifiers are not allowed");
        return context.fTypes.fPoison.get();
    }
 
    if (SkPopCount(precisionQualifiers.value()) > 1) {
        context.fErrors->error(pos, "only one precision qualifier can be used");
        return context.fTypes.fPoison.get();
    }
 
    // We're going to return a whole new type, so the modifier bits can be cleared out.
    *modifierFlags &= ~(ModifierFlag::kHighp |
                        ModifierFlag::kMediump |
                        ModifierFlag::kLowp);
 
    const Type& component = this->componentType();
    if (component.highPrecision()) {
        if (precisionQualifiers & ModifierFlag::kHighp) {
            // Type is already high precision, and we are requesting high precision. Return as-is.
            return this;
        }
 
        // SkSL doesn't support low precision, so `lowp` is interpreted as medium precision.
        // Ascertain the mediump equivalent type for this type, if any.
        const Type* mediumpType;
        switch (component.numberKind()) {
            case Type::NumberKind::kFloat:
                mediumpType = context.fTypes.fHalf.get();
                break;
 
            case Type::NumberKind::kSigned:
                mediumpType = context.fTypes.fShort.get();
                break;
 
            case Type::NumberKind::kUnsigned:
                mediumpType = context.fTypes.fUShort.get();
                break;
 
            default:
                mediumpType = context.fTypes.fPoison.get();
                break;
        }
 
        if (mediumpType) {
            // Convert the mediump component type into the final vector/matrix/array type as needed.
            return this->isArray()
                    ? context.fSymbolTable->addArrayDimension(context, mediumpType, this->columns())
                    : &mediumpType->toCompound(context, this->columns(), this->rows());
        }
    }
 
    context.fErrors->error(pos, "type '" + this->displayName() +
                                "' does not support precision qualifiers");
    return context.fTypes.fPoison.get();
}

◆ applyQualifiers()

const Type * SkSL::Type::applyQualifiers	(	const Context &	context,
		ModifierFlags *	modifierFlags,
		Position	pos
	)		const

Returns a type which honors the precision and access-level qualifiers set in ModifierFlags. For example:

Modifier mediump + Type float2: Type half2
Modifier readonly + Type texture2D: Type readonlyTexture2D Generates an error if the qualifiers don't make sense (highp bool, writeonly MyStruct)

Definition at line 936 of file SkSLType.cpp.

                                                      {
    const Type* type;
    type = this->applyPrecisionQualifiers(context, modifierFlags, pos);
    type = type->applyAccessQualifiers(context, modifierFlags, pos);
    return type;
}

◆ as() [1/2]

template<typename T >

T & SkSL::Type::as ( )

inline

Definition at line 216 of file SkSLType.h.

            {
        SkASSERT(this->is<T>());
        return static_cast<T&>(*this);
    }

◆ as() [2/2]

template<typename T >

const T & SkSL::Type::as ( ) const

inline

Definition at line 210 of file SkSLType.h.

                        {
        SkASSERT(this->is<T>());
        return static_cast<const T&>(*this);
    }

◆ bitWidth()

virtual int SkSL::Type::bitWidth ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, SkSL::ArrayType, SkSL::LiteralType, SkSL::ScalarType, SkSL::MatrixType, and SkSL::VectorType.

Definition at line 574 of file SkSLType.h.

                                 {
        return 0;
    }

◆ canCoerceTo()

bool SkSL::Type::canCoerceTo	(	const Type &	other,
		bool	allowNarrowing
	)		const

inline

Returns true if an instance of this type can be freely coerced (implicitly converted) to another type.

Definition at line 388 of file SkSLType.h.

                                                                   {
        return this->coercionCost(other).isPossible(allowNarrowing);
    }

◆ checkForOutOfRangeLiteral() [1/2]

bool SkSL::Type::checkForOutOfRangeLiteral	(	const Context &	context,
		const Expression &	expr
	)		const

Detects any IntLiterals in the expression which can't fit in this type.

Definition at line 1262 of file SkSLType.cpp.

                                                                                         {
    bool foundError = false;
    const Type& baseType = this->componentType();
    if (baseType.isNumber()) {
        // Replace constant expressions with their corresponding values.
        const Expression* valueExpr = ConstantFolder::GetConstantValueForVariable(expr);
        if (valueExpr->supportsConstantValues()) {
            // Iterate over every constant subexpression in the value.
            int numSlots = valueExpr->type().slotCount();
            for (int slot = 0; slot < numSlots; ++slot) {
                std::optional<double> slotVal = valueExpr->getConstantValue(slot);
                // Check for Literal values that are out of range for the base type.
                if (slotVal.has_value() &&
                    baseType.checkForOutOfRangeLiteral(context, *slotVal, valueExpr->fPosition)) {
                    foundError = true;
                }
            }
        }
    }
 
    // We don't need range checks for floats or booleans; any matched-type value is acceptable.
    return foundError;
}

◆ checkForOutOfRangeLiteral() [2/2]

bool SkSL::Type::checkForOutOfRangeLiteral	(	const Context &	context,
		double	value,
		Position	pos
	)		const

Checks if value can fit in this type. The type must be scalar.

Definition at line 1286 of file SkSLType.cpp.

                                                                                             {
    SkASSERT(this->isScalar());
    if (!this->isNumber()) {
       return false;
    }
    if (value >= this->minimumValue() && value <= this->maximumValue()) {
        return false;
    }
    // We found a value that can't fit in our type. Flag it as an error.
    context.fErrors->error(pos, SkSL::String::printf("value is out of range for type '%s': %.0f",
                                                     this->displayName().c_str(),
                                                     value));
    return true;
}

◆ checkIfUsableInArray()

bool SkSL::Type::checkIfUsableInArray	(	const Context &	context,
		Position	arrayPos
	)		const

Reports errors and returns false if this type cannot be used as the base type for an array.

Definition at line 1301 of file SkSLType.cpp.

                                                                               {
    if (this->isArray()) {
        context.fErrors->error(arrayPos, "multi-dimensional arrays are not supported");
        return false;
    }
    if (this->isVoid()) {
        context.fErrors->error(arrayPos, "type 'void' may not be used in an array");
        return false;
    }
    if (this->isOpaque() && !this->isAtomic()) {
        context.fErrors->error(arrayPos, "opaque type '" + std::string(this->name()) +
                                         "' may not be used in an array");
        return false;
    }
    return true;
}

◆ clone()

const Type * SkSL::Type::clone	(	const Context &	context,
		SymbolTable *	symbolTable
	)		const

Creates a clone of this Type, if needed, and inserts it into a different symbol table.

Definition at line 1185 of file SkSLType.cpp.

                                                                              {
    // Many types are built-ins, and exist in every SymbolTable by default.
    if (this->isInRootSymbolTable()) {
        return this;
    }
    // If we are compiling a program, and the type comes from the program's module, it is safe to
    // assume that the type is in-scope anywhere in the program without actually recursing through
    // the SymbolTable hierarchy to prove it.
    if (!context.fConfig->fIsBuiltinCode && this->isBuiltin()) {
        return this;
    }
    // Even if the type isn't a built-in, it might already exist in the SymbolTable. Search by name.
    const Symbol* existingSymbol = symbolTable->find(this->name());
    if (existingSymbol != nullptr) {
        const Type* existingType = &existingSymbol->as<Type>();
        SkASSERT(existingType->typeKind() == this->typeKind());
        return existingType;
    }
    // This type actually needs to be cloned into the destination SymbolTable.
    switch (this->typeKind()) {
        case TypeKind::kArray: {
            return symbolTable->addArrayDimension(context, &this->componentType(), this->columns());
        }
        case TypeKind::kStruct: {
            // We are cloning an existing struct, so there's no need to call MakeStructType and
            // fully error-check it again.
            const std::string* name = symbolTable->takeOwnershipOfString(std::string(this->name()));
            SkSpan<const Field> fieldSpan = this->fields();
            return symbolTable->add(
                    context,
                    std::make_unique<StructType>(this->fPosition,
                                                 *name,
                                                 TArray<Field>(fieldSpan.data(), fieldSpan.size()),
                                                 this->structNestingDepth(),
                                                 /*interfaceBlock=*/this->isInterfaceBlock(),
                                                 /*isBuiltin=*/context.fConfig->fIsBuiltinCode));
        }
        default:
            SkDEBUGFAILF("don't know how to clone type '%s'", this->description().c_str());
            return nullptr;
    }
}

◆ coerceExpression()

std::unique_ptr< Expression > SkSL::Type::coerceExpression	(	std::unique_ptr< Expression >	expr,
		const Context &	context
	)		const

Coerces the passed-in expression to this type. If the types are incompatible, reports an error and returns null.

Definition at line 1228 of file SkSLType.cpp.

                                                                                 {
    if (!expr || expr->isIncomplete(context)) {
        return nullptr;
    }
    if (expr->type().matches(*this)) {
        return expr;
    }
 
    const Position pos = expr->fPosition;
    const ProgramSettings& settings = context.fConfig->fSettings;
    if (!expr->coercionCost(*this).isPossible(settings.fAllowNarrowingConversions)) {
        context.fErrors->error(pos, "expected '" + this->displayName() + "', but found '" +
                                    expr->type().displayName() + "'");
        return nullptr;
    }
 
    if (this->isScalar()) {
        return ConstructorScalarCast::Make(context, pos, *this, std::move(expr));
    }
    if (this->isVector() || this->isMatrix()) {
        return ConstructorCompoundCast::Make(context, pos, *this, std::move(expr));
    }
    if (this->isArray()) {
        return ConstructorArrayCast::Make(context, pos, *this, std::move(expr));
    }
    context.fErrors->error(pos, "cannot construct '" + this->displayName() + "'");
    return nullptr;
}

◆ coercibleTypes()

virtual SkSpan< const Type *const > SkSL::Type::coercibleTypes ( ) const

inlinevirtual

For generic types, returns the types that this generic type can substitute for.

Reimplemented in SkSL::AliasType, and SkSL::GenericType.

Definition at line 476 of file SkSLType.h.

                                                             {
        SkDEBUGFAIL("Internal error: not a generic type");
        return {};
    }

◆ coercionCost()

CoercionCost SkSL::Type::coercionCost ( const Type & other ) const

Determines the "cost" of coercing (implicitly converting) this type to another type. The cost is a number with no particular meaning other than that lower costs are preferable to higher costs. Returns INT_MAX if the coercion is not possible.

Definition at line 899 of file SkSLType.cpp.

                                                       {
    if (this->matches(other)) {
        return CoercionCost::Free();
    }
    if (this->typeKind() == other.typeKind() &&
        (this->isVector() || this->isMatrix() || this->isArray())) {
        // Vectors/matrices/arrays of the same size can be coerced if their component type can be.
        if (this->isMatrix() && (this->rows() != other.rows())) {
            return CoercionCost::Impossible();
        }
        if (this->columns() != other.columns()) {
            return CoercionCost::Impossible();
        }
        return this->componentType().coercionCost(other.componentType());
    }
    if (this->isNumber() && other.isNumber()) {
        if (this->isLiteral() && this->isInteger()) {
            return CoercionCost::Free();
        } else if (this->numberKind() != other.numberKind()) {
            return CoercionCost::Impossible();
        } else if (other.priority() >= this->priority()) {
            return CoercionCost::Normal(other.priority() - this->priority());
        } else {
            return CoercionCost::Narrowing(this->priority() - other.priority());
        }
    }
    if (fTypeKind == TypeKind::kGeneric) {
        SkSpan<const Type* const> types = this->coercibleTypes();
        for (size_t i = 0; i < types.size(); i++) {
            if (types[i]->matches(other)) {
                return CoercionCost::Normal((int) i + 1);
            }
        }
    }
    return CoercionCost::Impossible();
}

◆ columns()

virtual int SkSL::Type::columns ( ) const

inlinevirtual

For matrices and vectors, returns the number of columns (e.g. both mat3 and float3 return 3). For scalars, returns 1. For arrays, returns either the size of the array (if known) or -1. For all other types, causes an assertion failure.

Reimplemented in SkSL::AliasType, SkSL::ArrayType, SkSL::LiteralType, SkSL::ScalarType, SkSL::MatrixType, and SkSL::VectorType.

Definition at line 429 of file SkSLType.h.

                                {
        SkDEBUGFAIL("type does not have columns");
        return -1;
    }

◆ columnType()

const Type & SkSL::Type::columnType ( const Context & context ) const

inline

For matrix types, returns the type of a single column (m[n]). Asserts for all other types.

Definition at line 411 of file SkSLType.h.

                                                         {
        return this->componentType().toCompound(context, this->rows(), /*rows=*/1);
    }

◆ componentType()

virtual const Type & SkSL::Type::componentType ( ) const

inlinevirtual

For matrices and vectors, returns the type of individual cells (e.g. mat2 has a component type of Float). For arrays, returns the base type. For all other types, returns the type itself.

Reimplemented in SkSL::AliasType, SkSL::ArrayType, SkSL::MatrixType, and SkSL::VectorType.

Definition at line 404 of file SkSLType.h.

                                              {
        return *this;
    }

◆ convertArraySize() [1/2]

SKSL_INT SkSL::Type::convertArraySize	(	const Context &	context,
		Position	arrayPos,
		Position	sizePos,
		SKSL_INT	size
	)		const

Definition at line 1333 of file SkSLType.cpp.

                                                     {
    if (!this->checkIfUsableInArray(context, arrayPos)) {
        // `checkIfUsableInArray` will generate an error for us.
        return 0;
    }
    if (size <= 0) {
        context.fErrors->error(sizePos, "array size must be positive");
        return 0;
    }
    // We can't get a meaningful slot count if the interior type contains an unsized array; we'll
    // assert if we try. Unsized arrays should only occur in a handful of limited cases (e.g. an
    // interface block with a trailing buffer), and will never be valid in a runtime effect.
    if (!this->isOrContainsUnsizedArray()) {
        if (SkSafeMath::Mul(this->slotCount(), size) > kVariableSlotLimit) {
            context.fErrors->error(sizePos, "array size is too large");
            return 0;
        }
    }
    return size;
}

◆ convertArraySize() [2/2]

SKSL_INT SkSL::Type::convertArraySize	(	const Context &	context,
		Position	arrayPos,
		std::unique_ptr< Expression >	size
	)		const

Verifies that the expression is a valid constant array size for this type. Returns the array size, or reports errors and returns zero if the expression isn't a valid literal value.

Definition at line 1318 of file SkSLType.cpp.

                                                                      {
    size = context.fTypes.fInt->coerceExpression(std::move(size), context);
    if (!size) {
        return 0;
    }
    SKSL_INT count;
    if (!ConstantFolder::GetConstantInt(*size, &count)) {
        context.fErrors->error(size->fPosition, "array size must be an integer");
        return 0;
    }
    return this->convertArraySize(context, arrayPos, size->fPosition, count);
}

◆ description()

std::string SkSL::Type::description ( ) const

inlineoverridevirtual

Implements SkSL::IRNode.

Definition at line 238 of file SkSLType.h.

                                           {
        return this->displayName();
    }

◆ dimensions()

virtual SpvDim_ SkSL::Type::dimensions ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, SkSL::TextureType, and SkSL::SamplerType.

Definition at line 481 of file SkSLType.h.

                                       {
        SkDEBUGFAIL("Internal error: not a texture type");
        return SpvDim1D;
    }

◆ displayName()

std::string SkSL::Type::displayName ( ) const

inline

Definition at line 234 of file SkSLType.h.

                                  {
        return std::string(this->scalarTypeForLiteral().name());
    }

◆ fields()

virtual SkSpan< const Field > SkSL::Type::fields ( ) const

inlinevirtual

Reimplemented in SkSL::StructType.

Definition at line 469 of file SkSLType.h.

                                               {
        SK_ABORT("Internal error: not a struct");
    }

◆ getArrayName()

std::string SkSL::Type::getArrayName ( int arraySize ) const

Converts a component type and a size (float, 10) into an array name ("float[10]").

Definition at line 756 of file SkSLType.cpp.

                                                {
    std::string_view name = this->name();
    if (arraySize == kUnsizedArray) {
        return String::printf("%.*s[]", (int)name.size(), name.data());
    }
    return String::printf("%.*s[%d]", (int)name.size(), name.data(), arraySize);
}

◆ hasPrecision()

bool SkSL::Type::hasPrecision ( ) const

inline

Definition at line 566 of file SkSLType.h.

                              {
        return this->componentType().isNumber() || this->isSampler();
    }

◆ highPrecision()

bool SkSL::Type::highPrecision ( ) const

inline

Definition at line 570 of file SkSLType.h.

                               {
        return this->bitWidth() >= 32;
    }

◆ is()

template<typename T >

bool SkSL::Type::is ( ) const

inline

Definition at line 205 of file SkSLType.h.

                    {
        return this->typeKind() == T::kTypeKind;
    }

◆ isAllowedInES2() [1/2]

virtual bool SkSL::Type::isAllowedInES2 ( ) const

inlinevirtual

Returns true if this type is legal to use in a strict-ES2 program.

Reimplemented in SkSL::AliasType, SkSL::ArrayType, SkSL::ScalarType, SkSL::AtomicType, SkSL::MatrixType, SkSL::StructType, and SkSL::VectorType.

Definition at line 246 of file SkSLType.h.

                                        {
        return true;
    }

◆ isAllowedInES2() [2/2]

bool SkSL::Type::isAllowedInES2 ( const Context & context ) const

Returns true if the program supports this type. Strict ES2 programs can't use ES3 types.

Definition at line 1258 of file SkSLType.cpp.

                                                      {
    return !context.fConfig->strictES2Mode() || this->isAllowedInES2();
}

◆ isAllowedInUniform()

virtual bool SkSL::Type::isAllowedInUniform ( Position * errorPosition = nullptr ) const

inlinevirtual

Returns true if this type is legal to use as a uniform. If false is returned, the errorPosition field may be populated; if it is, this position can be used to emit an extra diagnostic "caused by: <a field>" for nested types. Note that runtime effects enforce additional, much stricter rules about uniforms; these limitations are not handled here.

Reimplemented in SkSL::ScalarType, SkSL::AtomicType, SkSL::ArrayType, SkSL::StructType, and SkSL::VectorType.

Definition at line 257 of file SkSLType.h.

                                                                             {
        // We don't allow samplers, textures or atomics to be marked as uniforms.
        // This rules out all opaque types.
        return !this->isOpaque();
    }

◆ isArray()

virtual bool SkSL::Type::isArray ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, and SkSL::ArrayType.

Definition at line 532 of file SkSLType.h.

                                 {
        return false;
    }

◆ isArrayedTexture()

virtual bool SkSL::Type::isArrayedTexture ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, SkSL::TextureType, and SkSL::SamplerType.

Definition at line 491 of file SkSLType.h.

                                          {
        SkDEBUGFAIL("Internal error: not a texture type");
        return false;
    }

◆ isAtomic()

bool SkSL::Type::isAtomic ( ) const

inline

Definition at line 508 of file SkSLType.h.

                          {
        return this->typeKind() == TypeKind::kAtomic;
    }

◆ isBoolean()

bool SkSL::Type::isBoolean ( ) const

inline

Returns true if this type is a bool.

Definition at line 297 of file SkSLType.h.

                           {
        return this->numberKind() == NumberKind::kBoolean;
    }

◆ isBuiltin()

virtual bool SkSL::Type::isBuiltin ( ) const

inlinevirtual

Returns true if this type is known to come from BuiltinTypes, or is declared in a module. If this returns true, the Type will always be available in the root SymbolTable and never needs to be copied to migrate an Expression from one location to another. If it returns false, the Type might not exist in a separate SymbolTable and you'll need to consider cloning it.

Reimplemented in SkSL::ArrayType, and SkSL::StructType.

Definition at line 230 of file SkSLType.h.

                                   {
        return true;
    }

◆ isDepth()

virtual bool SkSL::Type::isDepth ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, SkSL::TextureType, and SkSL::SamplerType.

Definition at line 486 of file SkSLType.h.

                                 {
        SkDEBUGFAIL("Internal error: not a texture type");
        return false;
    }

◆ isEffectChild()

bool SkSL::Type::isEffectChild ( ) const

inline

Definition at line 550 of file SkSLType.h.

                               {
        return fTypeKind == TypeKind::kColorFilter ||
               fTypeKind == TypeKind::kShader ||
               fTypeKind == TypeKind::kBlender;
    }

◆ isFloat()

bool SkSL::Type::isFloat ( ) const

inline

Returns true if this is a floating-point scalar type (float or half).

Definition at line 318 of file SkSLType.h.

                         {
        return this->numberKind() == NumberKind::kFloat;
    }

◆ isGeneric()

bool SkSL::Type::isGeneric ( ) const

inline

Definition at line 500 of file SkSLType.h.

                           {
        return fTypeKind == TypeKind::kGeneric;
    }

◆ isInRootSymbolTable()

bool SkSL::Type::isInRootSymbolTable ( ) const

inlineprotected

Only structs and arrays can be created in code; all other types exist in the root.

Definition at line 655 of file SkSLType.h.

                                     {
        return !(this->isArray() || this->isStruct());
    }

◆ isInteger()

bool SkSL::Type::isInteger ( ) const

inline

Returns true if this is a signed or unsigned integer.

Definition at line 339 of file SkSLType.h.

                           {
        switch (this->numberKind()) {
            case NumberKind::kSigned:
            case NumberKind::kUnsigned:
                return true;
            default:
                return false;
        }
    }

◆ isInterfaceBlock()

virtual bool SkSL::Type::isInterfaceBlock ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, and SkSL::StructType.

Definition at line 544 of file SkSLType.h.

                                          {
        return false;
    }

◆ isLiteral()

virtual bool SkSL::Type::isLiteral ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, and SkSL::LiteralType.

Definition at line 516 of file SkSLType.h.

                                   {
        return false;
    }

◆ isMatrix()

virtual bool SkSL::Type::isMatrix ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, and SkSL::MatrixType.

Definition at line 528 of file SkSLType.h.

                                  {
        return false;
    }

◆ isMultisampled()

virtual bool SkSL::Type::isMultisampled ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, SkSL::TextureType, and SkSL::SamplerType.

Definition at line 556 of file SkSLType.h.

                                        {
        SkDEBUGFAIL("not a texture type");
        return false;
    }

◆ isNumber()

bool SkSL::Type::isNumber ( ) const

inline

Returns true if this is a numeric scalar type.

Definition at line 304 of file SkSLType.h.

                          {
        switch (this->numberKind()) {
            case NumberKind::kFloat:
            case NumberKind::kSigned:
            case NumberKind::kUnsigned:
                return true;
            default:
                return false;
        }
    }

◆ isOpaque()

bool SkSL::Type::isOpaque ( ) const

inline

Returns true if this is an "opaque type" (an external object which the shader references in some fashion). https://www.khronos.org/opengl/wiki/Data_Type_(GLSL)#Opaque_types

Definition at line 353 of file SkSLType.h.

                          {
        switch (fTypeKind) {
            case TypeKind::kAtomic:
            case TypeKind::kBlender:
            case TypeKind::kColorFilter:
            case TypeKind::kSampler:
            case TypeKind::kSeparateSampler:
            case TypeKind::kShader:
            case TypeKind::kTexture:
                return true;
            default:
                return false;
        }
    }

◆ isOrContainsArray()

virtual bool SkSL::Type::isOrContainsArray ( ) const

inlinevirtual

Reimplemented in SkSL::ArrayType, and SkSL::StructType.

Definition at line 578 of file SkSLType.h.

                                           {
        return false;
    }

◆ isOrContainsAtomic()

virtual bool SkSL::Type::isOrContainsAtomic ( ) const

inlinevirtual

Reimplemented in SkSL::ArrayType, SkSL::AtomicType, and SkSL::StructType.

Definition at line 586 of file SkSLType.h.

                                            {
        return false;
    }

◆ isOrContainsUnsizedArray()

virtual bool SkSL::Type::isOrContainsUnsizedArray ( ) const

inlinevirtual

Reimplemented in SkSL::ArrayType, and SkSL::StructType.

Definition at line 582 of file SkSLType.h.

                                                  {
        return false;
    }

◆ isSampler()

bool SkSL::Type::isSampler ( ) const

inline

Definition at line 504 of file SkSLType.h.

                           {
        return fTypeKind == TypeKind::kSampler;
    }

◆ isScalar()

virtual bool SkSL::Type::isScalar ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, SkSL::LiteralType, and SkSL::ScalarType.

Definition at line 512 of file SkSLType.h.

                                  {
        return false;
    }

◆ isSigned()

bool SkSL::Type::isSigned ( ) const

inline

Returns true if this is a signed scalar type (int or short).

Definition at line 325 of file SkSLType.h.

                          {
        return this->numberKind() == NumberKind::kSigned;
    }

◆ isStorageTexture()

bool SkSL::Type::isStorageTexture ( ) const

inline

Returns true if this is a storage texture.

Definition at line 371 of file SkSLType.h.

                                  {
        return fTypeKind == TypeKind::kTexture && this->dimensions() != SpvDimSubpassData;
    }

◆ isStruct()

virtual bool SkSL::Type::isStruct ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, and SkSL::StructType.

Definition at line 540 of file SkSLType.h.

                                  {
        return false;
    }

◆ isUnsigned()

bool SkSL::Type::isUnsigned ( ) const

inline

Returns true if this is an unsigned scalar type (uint or ushort).

Definition at line 332 of file SkSLType.h.

                            {
        return this->numberKind() == NumberKind::kUnsigned;
    }

◆ isUnsizedArray()

virtual bool SkSL::Type::isUnsizedArray ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, and SkSL::ArrayType.

Definition at line 536 of file SkSLType.h.

                                        {
        return false;
    }

◆ isVector()

virtual bool SkSL::Type::isVector ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, and SkSL::VectorType.

Definition at line 524 of file SkSLType.h.

                                  {
        return false;
    }

◆ isVoid()

bool SkSL::Type::isVoid ( ) const

inline

Definition at line 496 of file SkSLType.h.

                        {
        return fTypeKind == TypeKind::kVoid;
    }

◆ MakeAliasType()

std::unique_ptr< Type > SkSL::Type::MakeAliasType	(	std::string_view	name,
		const Type &	targetType
	)

static

Creates an alias which maps to another type.

Definition at line 764 of file SkSLType.cpp.

                                                                                   {
    return std::make_unique<AliasType>(std::move(name), targetType);
}

◆ MakeArrayType()

std::unique_ptr< Type > SkSL::Type::MakeArrayType	(	const Context &	context,
		std::string_view	name,
		const Type &	componentType,
		int	columns
	)

static

Creates an array type. columns may be kUnsizedArray.

Definition at line 768 of file SkSLType.cpp.

                                                       {
    return std::make_unique<ArrayType>(std::move(name), componentType.abbreviatedName(),
                                       componentType, columns, context.fConfig->fIsBuiltinCode);
}

◆ MakeAtomicType()

std::unique_ptr< Type > SkSL::Type::MakeAtomicType	(	std::string_view	name,
		const char *	abbrev
	)

static

Create an atomic type.

Definition at line 807 of file SkSLType.cpp.

                                                                                {
    return std::make_unique<AtomicType>(name, abbrev);
}

◆ MakeGenericType()

std::unique_ptr< Type > SkSL::Type::MakeGenericType	(	const char *	name,
		SkSpan< const Type *const >	types,
		const Type *	slotType
	)

static

Create a generic type which maps to the listed types–e.g. $genType is a generic type which can match float, float2, float3 or float4.

Definition at line 776 of file SkSLType.cpp.

                                                                  {
    return std::make_unique<GenericType>(name, types, slotType);
}

◆ MakeLiteralType()

std::unique_ptr< Type > SkSL::Type::MakeLiteralType	(	const char *	name,
		const Type &	scalarType,
		int8_t	priority
	)

static

Create a type for literal scalars.

Definition at line 782 of file SkSLType.cpp.

                                                             {
    return std::make_unique<LiteralType>(name, scalarType, priority);
}

◆ MakeMatrixType()

std::unique_ptr< Type > SkSL::Type::MakeMatrixType	(	std::string_view	name,
		const char *	abbrev,
		const Type &	componentType,
		int	columns,
		int8_t	rows
	)

static

Create a matrix type.

Definition at line 787 of file SkSLType.cpp.

                                                                                                {
    return std::make_unique<MatrixType>(name, abbrev, componentType, columns, rows);
}

◆ MakeSamplerType()

std::unique_ptr< Type > SkSL::Type::MakeSamplerType	(	const char *	name,
		const Type &	textureType
	)

static

Create a sampler type.

Definition at line 792 of file SkSLType.cpp.

                                                                                   {
    return std::make_unique<SamplerType>(name, textureType);
}

◆ MakeScalarType()

std::unique_ptr< Type > SkSL::Type::MakeScalarType	(	std::string_view	name,
		const char *	abbrev,
		Type::NumberKind	numberKind,
		int8_t	priority,
		int8_t	bitWidth
	)

static

Create a scalar type.

Definition at line 801 of file SkSLType.cpp.

                                                            {
    return std::make_unique<ScalarType>(name, abbrev, numberKind, priority, bitWidth);
}

◆ MakeSpecialType()

std::unique_ptr< Type > SkSL::Type::MakeSpecialType	(	const char *	name,
		const char *	abbrev,
		Type::TypeKind	typeKind
	)

static

Create a "special" type with the given name, abbreviation, and TypeKind.

Definition at line 796 of file SkSLType.cpp.

                                                                   {
    return std::unique_ptr<Type>(new Type(name, abbrev, typeKind));
}

◆ MakeStructType()

std::unique_ptr< Type > SkSL::Type::MakeStructType	(	const Context &	context,
		Position	pos,
		std::string_view	name,
		skia_private::TArray< Field >	fields,
		bool	interfaceBlock = `false`
	)

static

Creates a struct type with the given fields. Reports an error if the struct is not well-formed.

Definition at line 811 of file SkSLType.cpp.

                                                                {
    const char* const structOrIB  = interfaceBlock ? "interface block" : "struct";
    const char* const aStructOrIB = interfaceBlock ? "an interface block" : "a struct";
 
    if (fields.empty()) {
        context.fErrors->error(pos, std::string(structOrIB) + " '" + std::string(name) +
                                    "' must contain at least one field");
    }
    size_t slots = 0;
 
    THashSet<std::string_view> fieldNames;
    for (const Field& field : fields) {
        // Add this field name to our set; if the set doesn't grow, we found a duplicate.
        int numFieldNames = fieldNames.count();
        fieldNames.add(field.fName);
        if (fieldNames.count() == numFieldNames) {
            context.fErrors->error(field.fPosition, "field '" + std::string(field.fName) +
                                                    "' was already defined in the same " +
                                                    std::string(structOrIB) + " ('" +
                                                    std::string(name) + "')");
        }
        if (field.fModifierFlags != ModifierFlag::kNone) {
            std::string desc = field.fModifierFlags.description();
            context.fErrors->error(field.fPosition, "modifier '" + desc + "' is not permitted on " +
                                                    std::string(aStructOrIB) + " field");
        }
        if (field.fLayout.fFlags & LayoutFlag::kBinding) {
            context.fErrors->error(field.fPosition, "layout qualifier 'binding' is not permitted "
                                                    "on " + std::string(aStructOrIB) + " field");
        }
        if (field.fLayout.fFlags & LayoutFlag::kSet) {
            context.fErrors->error(field.fPosition, "layout qualifier 'set' is not permitted on " +
                                                    std::string(aStructOrIB) + " field");
        }
 
        if (field.fType->isVoid()) {
            context.fErrors->error(field.fPosition, "type 'void' is not permitted in " +
                                                    std::string(aStructOrIB));
        }
        if (field.fType->isOpaque() && !field.fType->isAtomic()) {
            context.fErrors->error(field.fPosition, "opaque type '" + field.fType->displayName() +
                                                    "' is not permitted in " +
                                                    std::string(aStructOrIB));
        }
        if (field.fType->isOrContainsUnsizedArray()) {
            if (!interfaceBlock) {
                // Reject unsized arrays anywhere in structs.
                context.fErrors->error(field.fPosition, "unsized arrays are not permitted here");
            }
        } else {
            // If we haven't already exceeded the struct size limit...
            if (slots < kVariableSlotLimit) {
                // ... see if this field causes us to exceed the size limit.
                slots = SkSafeMath::Add(slots, field.fType->slotCount());
                if (slots >= kVariableSlotLimit) {
                    context.fErrors->error(pos, std::string(structOrIB) + " is too large");
                }
            }
        }
    }
    int nestingDepth = 0;
    for (const Field& field : fields) {
        nestingDepth = std::max(nestingDepth, field.fType->structNestingDepth());
    }
    if (nestingDepth >= kMaxStructDepth) {
        context.fErrors->error(pos, std::string(structOrIB) + " '" + std::string(name) +
                                    "' is too deeply nested");
    }
    return std::make_unique<StructType>(pos, name, std::move(fields), nestingDepth + 1,
                                        interfaceBlock, context.fConfig->fIsBuiltinCode);
}

◆ MakeTextureType()

std::unique_ptr< Type > SkSL::Type::MakeTextureType	(	const char *	name,
		SpvDim_	dimensions,
		bool	isDepth,
		bool	isArrayedTexture,
		bool	isMultisampled,
		TextureAccess	textureAccess
	)

static

Create a texture type.

Definition at line 887 of file SkSLType.cpp.

                                                                         {
    return std::make_unique<TextureType>(name, dimensions, isDepth, isArrayedTexture,
                                         isMultisampled, textureAccess);
}

◆ MakeVectorType()

std::unique_ptr< Type > SkSL::Type::MakeVectorType	(	std::string_view	name,
		const char *	abbrev,
		const Type &	componentType,
		int	columns
	)

static

Create a vector type.

Definition at line 894 of file SkSLType.cpp.

                                                                                   {
    return std::make_unique<VectorType>(name, abbrev, componentType, columns);
}

◆ matches()

bool SkSL::Type::matches ( const Type & other ) const

inline

Returns true if these types are equal after alias resolution.

Definition at line 269 of file SkSLType.h.

                                          {
        return this->resolve().name() == other.resolve().name();
    }

◆ maximumValue()

virtual double SkSL::Type::maximumValue ( ) const

inlinevirtual

Reimplemented in SkSL::LiteralType, and SkSL::ScalarType.

Definition at line 449 of file SkSLType.h.

                                        {
        SkDEBUGFAIL("type does not have a maximum value");
        return +INFINITY;
    }

◆ minimumValue()

virtual double SkSL::Type::minimumValue ( ) const

inlinevirtual

Returns the minimum value that can fit in the type.

Reimplemented in SkSL::LiteralType, and SkSL::ScalarType.

Definition at line 444 of file SkSLType.h.

                                        {
        SkDEBUGFAIL("type does not have a minimum value");
        return -INFINITY;
    }

◆ numberKind()

virtual NumberKind SkSL::Type::numberKind ( ) const

inlinevirtual

Returns the NumberKind of this type (always kNonnumeric for non-scalar values).

Reimplemented in SkSL::AliasType, SkSL::LiteralType, and SkSL::ScalarType.

Definition at line 290 of file SkSLType.h.

                                          {
        return NumberKind::kNonnumeric;
    }

◆ priority()

virtual int SkSL::Type::priority ( ) const

inlinevirtual

Returns the "priority" of a number type, in order of float > half > int > short. When operating on two number types, the result is the higher-priority type.

Reimplemented in SkSL::AliasType, SkSL::LiteralType, and SkSL::ScalarType.

Definition at line 379 of file SkSLType.h.

                                 {
        SkDEBUGFAIL("not a number type");
        return -1;
    }

◆ resolve()

virtual const Type & SkSL::Type::resolve ( ) const

inlinevirtual

If this is an alias, returns the underlying type, otherwise returns this.

Reimplemented in SkSL::AliasType.

Definition at line 264 of file SkSLType.h.

                                        {
        return *this;
    }

◆ rows()

virtual int SkSL::Type::rows ( ) const

inlinevirtual

For matrices, returns the number of rows (e.g. mat2x4 returns 4). For vectors and scalars, returns 1. For all other types, causes an assertion failure.

Reimplemented in SkSL::AliasType, SkSL::LiteralType, SkSL::ScalarType, SkSL::MatrixType, and SkSL::VectorType.

Definition at line 438 of file SkSLType.h.

                             {
        SkDEBUGFAIL("type does not have rows");
        return -1;
    }

◆ scalarTypeForLiteral()

virtual const Type & SkSL::Type::scalarTypeForLiteral ( ) const

inlinevirtual

Reimplemented in SkSL::LiteralType.

Definition at line 520 of file SkSLType.h.

                                                     {
        return *this;
    }

◆ slotCount()

virtual size_t SkSL::Type::slotCount ( ) const

inlinevirtual

Returns the number of scalars needed to hold this type.

Reimplemented in SkSL::AliasType, SkSL::ArrayType, SkSL::LiteralType, SkSL::ScalarType, SkSL::MatrixType, SkSL::StructType, and SkSL::VectorType.

Definition at line 457 of file SkSLType.h.

                                     {
        return 0;
    }

◆ slotType()

virtual const Type & SkSL::Type::slotType ( size_t ) const

inlinevirtual

Returns the type of the value in the nth slot. For scalar, vector and matrix types, should always match componentType().

Reimplemented in SkSL::AliasType, SkSL::ArrayType, SkSL::LiteralType, SkSL::ScalarType, SkSL::AtomicType, SkSL::MatrixType, SkSL::TextureType, SkSL::SamplerType, SkSL::StructType, SkSL::VectorType, and SkSL::GenericType.

Definition at line 465 of file SkSLType.h.

                                               {
        return *this;
    }

◆ structNestingDepth()

virtual int SkSL::Type::structNestingDepth ( ) const

inlineprotectedvirtual

If the type is a struct, returns the depth of the struct's most deeply-nested field.

Reimplemented in SkSL::StructType.

Definition at line 660 of file SkSLType.h.

                                           {
        return 0;
    }

◆ textureAccess()

virtual TextureAccess SkSL::Type::textureAccess ( ) const

inlinevirtual

Reimplemented in SkSL::AliasType, SkSL::TextureType, and SkSL::SamplerType.

Definition at line 561 of file SkSLType.h.

                                                {
        SkDEBUGFAIL("not a texture type");
        return TextureAccess::kSample;
    }

◆ textureType()

virtual const Type & SkSL::Type::textureType ( ) const

inlinevirtual

For texture samplers, returns the type of texture it samples (e.g., sampler2D has a texture type of texture2D).

Reimplemented in SkSL::SamplerType.

Definition at line 419 of file SkSLType.h.

                                            {
        SkDEBUGFAIL("not a sampler type");
        return *this;
    }

◆ toCompound()

const Type & SkSL::Type::toCompound	(	const Context &	context,
		int	columns,
		int	rows
	)		const

Returns the corresponding vector or matrix type with the specified number of columns and rows.

Definition at line 1049 of file SkSLType.cpp.

                                                                                {
    SkASSERT(this->isScalar());
    if (columns == 1 && rows == 1) {
        return *this;
    }
    if (this->matches(*context.fTypes.fFloat) || this->matches(*context.fTypes.fFloatLiteral)) {
        switch (rows) {
            case 1:
                switch (columns) {
                    case 1: return *context.fTypes.fFloat;
                    case 2: return *context.fTypes.fFloat2;
                    case 3: return *context.fTypes.fFloat3;
                    case 4: return *context.fTypes.fFloat4;
                    default: SK_ABORT("unsupported vector column count (%d)", columns);
                }
            case 2:
                switch (columns) {
                    case 2: return *context.fTypes.fFloat2x2;
                    case 3: return *context.fTypes.fFloat3x2;
                    case 4: return *context.fTypes.fFloat4x2;
                    default: SK_ABORT("unsupported matrix column count (%d)", columns);
                }
            case 3:
                switch (columns) {
                    case 2: return *context.fTypes.fFloat2x3;
                    case 3: return *context.fTypes.fFloat3x3;
                    case 4: return *context.fTypes.fFloat4x3;
                    default: SK_ABORT("unsupported matrix column count (%d)", columns);
                }
            case 4:
                switch (columns) {
                    case 2: return *context.fTypes.fFloat2x4;
                    case 3: return *context.fTypes.fFloat3x4;
                    case 4: return *context.fTypes.fFloat4x4;
                    default: SK_ABORT("unsupported matrix column count (%d)", columns);
                }
            default: SK_ABORT("unsupported row count (%d)", rows);
        }
    } else if (this->matches(*context.fTypes.fHalf)) {
        switch (rows) {
            case 1:
                switch (columns) {
                    case 1: return *context.fTypes.fHalf;
                    case 2: return *context.fTypes.fHalf2;
                    case 3: return *context.fTypes.fHalf3;
                    case 4: return *context.fTypes.fHalf4;
                    default: SK_ABORT("unsupported vector column count (%d)", columns);
                }
            case 2:
                switch (columns) {
                    case 2: return *context.fTypes.fHalf2x2;
                    case 3: return *context.fTypes.fHalf3x2;
                    case 4: return *context.fTypes.fHalf4x2;
                    default: SK_ABORT("unsupported matrix column count (%d)", columns);
                }
            case 3:
                switch (columns) {
                    case 2: return *context.fTypes.fHalf2x3;
                    case 3: return *context.fTypes.fHalf3x3;
                    case 4: return *context.fTypes.fHalf4x3;
                    default: SK_ABORT("unsupported matrix column count (%d)", columns);
                }
            case 4:
                switch (columns) {
                    case 2: return *context.fTypes.fHalf2x4;
                    case 3: return *context.fTypes.fHalf3x4;
                    case 4: return *context.fTypes.fHalf4x4;
                    default: SK_ABORT("unsupported matrix column count (%d)", columns);
                }
            default: SK_ABORT("unsupported row count (%d)", rows);
        }
    } else if (this->matches(*context.fTypes.fInt) || this->matches(*context.fTypes.fIntLiteral)) {
        switch (rows) {
            case 1:
                switch (columns) {
                    case 1: return *context.fTypes.fInt;
                    case 2: return *context.fTypes.fInt2;
                    case 3: return *context.fTypes.fInt3;
                    case 4: return *context.fTypes.fInt4;
                    default: SK_ABORT("unsupported vector column count (%d)", columns);
                }
            default: SK_ABORT("unsupported row count (%d)", rows);
        }
    } else if (this->matches(*context.fTypes.fShort)) {
        switch (rows) {
            case 1:
                switch (columns) {
                    case 1: return *context.fTypes.fShort;
                    case 2: return *context.fTypes.fShort2;
                    case 3: return *context.fTypes.fShort3;
                    case 4: return *context.fTypes.fShort4;
                    default: SK_ABORT("unsupported vector column count (%d)", columns);
                }
            default: SK_ABORT("unsupported row count (%d)", rows);
        }
    } else if (this->matches(*context.fTypes.fUInt)) {
        switch (rows) {
            case 1:
                switch (columns) {
                    case 1: return *context.fTypes.fUInt;
                    case 2: return *context.fTypes.fUInt2;
                    case 3: return *context.fTypes.fUInt3;
                    case 4: return *context.fTypes.fUInt4;
                    default: SK_ABORT("unsupported vector column count (%d)", columns);
                }
            default: SK_ABORT("unsupported row count (%d)", rows);
        }
    } else if (this->matches(*context.fTypes.fUShort)) {
        switch (rows) {
            case 1:
                switch (columns) {
                    case 1: return *context.fTypes.fUShort;
                    case 2: return *context.fTypes.fUShort2;
                    case 3: return *context.fTypes.fUShort3;
                    case 4: return *context.fTypes.fUShort4;
                    default: SK_ABORT("unsupported vector column count (%d)", columns);
                }
            default: SK_ABORT("unsupported row count (%d)", rows);
        }
    } else if (this->matches(*context.fTypes.fBool)) {
        switch (rows) {
            case 1:
                switch (columns) {
                    case 1: return *context.fTypes.fBool;
                    case 2: return *context.fTypes.fBool2;
                    case 3: return *context.fTypes.fBool3;
                    case 4: return *context.fTypes.fBool4;
                    default: SK_ABORT("unsupported vector column count (%d)", columns);
                }
            default: SK_ABORT("unsupported row count (%d)", rows);
        }
    }
    SkDEBUGFAILF("unsupported toCompound type %s", this->description().c_str());
    return *context.fTypes.fVoid;
}

◆ typeKind()

TypeKind SkSL::Type::typeKind ( ) const

inline

Returns the category (scalar, vector, matrix, etc.) of this type.

Definition at line 283 of file SkSLType.h.

                              {
        return fTypeKind;
    }

Member Data Documentation

◆ kIRNodeKind

constexpr Kind SkSL::Type::kIRNodeKind = Kind::kType

inlinestaticconstexpr

Definition at line 96 of file SkSLType.h.

◆ kMaxAbbrevLength

constexpr int SkSL::Type::kMaxAbbrevLength = 3

inlinestaticconstexpr

Definition at line 97 of file SkSLType.h.

◆ kUnsizedArray

constexpr int SkSL::Type::kUnsizedArray = -1

inlinestaticconstexpr

Definition at line 99 of file SkSLType.h.

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

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ NumberKind

◆ TextureAccess

◆ TypeKind

Constructor & Destructor Documentation

◆ Type() [1/2]

◆ Type() [2/2]

Member Function Documentation

◆ abbreviatedName()

◆ applyAccessQualifiers()

◆ applyPrecisionQualifiers()

◆ applyQualifiers()

◆ as() [1/2]

◆ as() [2/2]

◆ bitWidth()

◆ canCoerceTo()

◆ checkForOutOfRangeLiteral() [1/2]

◆ checkForOutOfRangeLiteral() [2/2]

◆ checkIfUsableInArray()

◆ clone()

◆ coerceExpression()

◆ coercibleTypes()

◆ coercionCost()

◆ columns()

◆ columnType()

◆ componentType()

◆ convertArraySize() [1/2]

◆ convertArraySize() [2/2]

◆ description()

◆ dimensions()

◆ displayName()

◆ fields()

◆ getArrayName()

◆ hasPrecision()

◆ highPrecision()

◆ is()

◆ isAllowedInES2() [1/2]

◆ isAllowedInES2() [2/2]

◆ isAllowedInUniform()

◆ isArray()

◆ isArrayedTexture()

◆ isAtomic()

◆ isBoolean()

◆ isBuiltin()

◆ isDepth()

◆ isEffectChild()

◆ isFloat()

◆ isGeneric()

◆ isInRootSymbolTable()

◆ isInteger()

◆ isInterfaceBlock()

◆ isLiteral()

◆ isMatrix()

◆ isMultisampled()

◆ isNumber()

◆ isOpaque()

◆ isOrContainsArray()

◆ isOrContainsAtomic()

◆ isOrContainsUnsizedArray()

◆ isSampler()

◆ isScalar()

◆ isSigned()

◆ isStorageTexture()

◆ isStruct()

◆ isUnsigned()

◆ isUnsizedArray()

◆ isVector()

◆ isVoid()

◆ MakeAliasType()

◆ MakeArrayType()

◆ MakeAtomicType()

◆ MakeGenericType()

◆ MakeLiteralType()