SkSL::ConstructorCompoundCast Class Reference

#include <SkSLConstructorCompoundCast.h>

Inheritance diagram for SkSL::ConstructorCompoundCast:

Public Member Functions
	ConstructorCompoundCast (Position pos, const Type &type, std::unique_ptr< Expression > arg)
std::unique_ptr< Expression >	clone (Position pos) const override
Public Member Functions inherited from SkSL::SingleArgumentConstructor
	SingleArgumentConstructor (Position pos, Kind kind, const Type *type, std::unique_ptr< Expression > argument)
std::unique_ptr< Expression > &	argument ()
const std::unique_ptr< Expression > &	argument () const
SkSpan< std::unique_ptr< Expression > >	argumentSpan () final
SkSpan< const std::unique_ptr< Expression > >	argumentSpan () const final
Public Member Functions inherited from SkSL::AnyConstructor
	AnyConstructor (Position pos, Kind kind, const Type *type)
std::string	description (OperatorPrecedence) const override
const Type &	componentType () const
bool	supportsConstantValues () const override
std::optional< double >	getConstantValue (int n) const override
ComparisonResult	compareConstant (const Expression &other) 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
CoercionCost	coercionCost (const Type &target) 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 >	Make (const Context &context, Position pos, const Type &type, std::unique_ptr< Expression > arg)
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::kConstructorCompoundCast

Additional Inherited Members
Public Types inherited from SkSL::Expression
enum class	ComparisonResult { kUnknown = -1 , kNotEqual , kEqual }
using	Kind = ExpressionKind
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 the construction of a vector/matrix typecast, such as half3(myInt3) or float4x4(myHalf4x4). Matrix resizes are done in ConstructorMatrixResize, not here.

These always contain exactly 1 vector or matrix of matching size, and are never constant.

Definition at line 30 of file SkSLConstructorCompoundCast.h.

Constructor & Destructor Documentation

ConstructorCompoundCast()

SkSL::ConstructorCompoundCast::ConstructorCompoundCast ( Position  pos, const Type &  type, std::unique_ptr< Expression >  arg  )

inline

Definition at line 34 of file SkSLConstructorCompoundCast.h.

        : INHERITED(pos, kIRNodeKind, &type, std::move(arg)) {}

Member Function Documentation

clone()

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

inlineoverridevirtual

Implements SkSL::Expression.

Definition at line 42 of file SkSLConstructorCompoundCast.h.

                                                                 {
        return std::make_unique<ConstructorCompoundCast>(pos, this->type(), argument()->clone());
    }

Make()

std::unique_ptr< Expression > SkSL::ConstructorCompoundCast::Make ( const Context &  context, Position  pos, const Type &  type, std::unique_ptr< Expression >  arg  )

static

Definition at line 72 of file SkSLConstructorCompoundCast.cpp.

                                                                                         {
    // Only vectors or matrices of the same dimensions are allowed.
    SkASSERT(type.isVector() || type.isMatrix());
    SkASSERT(type.isAllowedInES2(context));
    SkASSERT(arg->type().isVector() == type.isVector());
    SkASSERT(arg->type().isMatrix() == type.isMatrix());
    SkASSERT(type.columns() == arg->type().columns());
    SkASSERT(type.rows() == arg->type().rows());
 
    // If this is a no-op cast, return the expression as-is.
    if (type.matches(arg->type())) {
        arg->setPosition(pos);
        return arg;
    }
    // Look up the value of constant variables. This allows constant-expressions like
    // `int4(colorGreen)` to be replaced with the compile-time constant `int4(0, 1, 0, 1)`.
    arg = ConstantFolder::MakeConstantValueForVariable(pos, std::move(arg));
 
    // We can cast a vector of compile-time constants at compile-time.
    if (Analysis::IsCompileTimeConstant(*arg)) {
        return cast_constant_composite(context, pos, type, std::move(arg));
    }
    return std::make_unique<ConstructorCompoundCast>(pos, type, std::move(arg));
}

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::ConstructorCompoundCast::kIRNodeKind = Kind::kConstructorCompoundCast

inlinestaticconstexpr

Definition at line 32 of file SkSLConstructorCompoundCast.h.

---

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

• third_party/skia/src/sksl/ir/SkSLConstructorCompoundCast.h
• third_party/skia/src/sksl/ir/SkSLConstructorCompoundCast.cpp