SkSL::InterfaceBlock Class Reference

#include <SkSLInterfaceBlock.h>

Inheritance diagram for SkSL::InterfaceBlock:

Public Member Functions
	InterfaceBlock (Position pos, Variable *var)
	~InterfaceBlock () override
Variable *	var () const
void	detachDeadVariable ()
std::string_view	typeName () const
std::string_view	instanceName () const
int	arraySize () const
std::string	description () const override
Public Member Functions inherited from SkSL::ProgramElement
	ProgramElement (Position pos, Kind kind)
Kind	kind () const
Public Member Functions inherited from SkSL::IRNode
virtual	~IRNode ()
virtual std::string	description () const =0
	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< InterfaceBlock >	Convert (const Context &context, Position pos, const Modifiers &modifiers, std::string_view typeName, skia_private::TArray< Field > fields, std::string_view varName, int arraySize)
static std::unique_ptr< InterfaceBlock >	Make (const Context &context, Position pos, Variable *variable)
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::kInterfaceBlock

Additional Inherited Members
Public Types inherited from SkSL::ProgramElement
using	Kind = ProgramElementKind
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

An interface block, as in:

out sk_PerVertex { layout(builtin=0) float4 sk_Position; layout(builtin=1) float sk_PointSize; };

At the IR level, this is represented by a single variable of struct type.

Definition at line 38 of file SkSLInterfaceBlock.h.

Constructor & Destructor Documentation

InterfaceBlock()

SkSL::InterfaceBlock::InterfaceBlock ( Position  pos, Variable *  var  )

inline

Definition at line 42 of file SkSLInterfaceBlock.h.

            : INHERITED(pos, kIRNodeKind)
            , fVariable(var) {
        SkASSERT(fVariable->type().componentType().isInterfaceBlock());
        fVariable->setInterfaceBlock(this);
    }

~InterfaceBlock()

SkSL::InterfaceBlock::~InterfaceBlock ( )

override

Definition at line 34 of file SkSLInterfaceBlock.cpp.

                                {
    // Unhook this InterfaceBlock from its associated Variable, since we're being deleted.
    if (fVariable) {
        fVariable->detachDeadInterfaceBlock();
    }
}

Member Function Documentation

arraySize()

int SkSL::InterfaceBlock::arraySize ( ) const

inline

Definition at line 88 of file SkSLInterfaceBlock.h.

                          {
        return fVariable->type().isArray() ? fVariable->type().columns() : 0;
    }

Convert()

std::unique_ptr< InterfaceBlock > SkSL::InterfaceBlock::Convert ( const Context &  context, Position  pos, const Modifiers &  modifiers, std::string_view  typeName, skia_private::TArray< Field >  fields, std::string_view  varName, int  arraySize  )

static

Definition at line 52 of file SkSLInterfaceBlock.cpp.

                                                                       {
    if (SkSL::ProgramKind kind = context.fConfig->fKind; !ProgramConfig::IsFragment(kind) &&
                                                         !ProgramConfig::IsVertex(kind) &&
                                                         !ProgramConfig::IsCompute(kind)) {
        context.fErrors->error(pos, "interface blocks are not allowed in this kind of program");
        return nullptr;
    }
    // Find sk_RTAdjust and error out if it's not of type `float4`.
    std::optional<int> rtAdjustIndex = find_rt_adjust_index(fields);
    if (rtAdjustIndex.has_value()) {
        const Field& rtAdjustField = fields[*rtAdjustIndex];
        if (!rtAdjustField.fType->matches(*context.fTypes.fFloat4)) {
            context.fErrors->error(rtAdjustField.fPosition, "sk_RTAdjust must have type 'float4'");
            return nullptr;
        }
    }
    // Build a struct type corresponding to the passed-in fields.
    const Type* baseType = context.fSymbolTable->add(context,
                                                     Type::MakeStructType(context,
                                                                          pos,
                                                                          typeName,
                                                                          std::move(fields),
                                                                          /*interfaceBlock=*/true));
    // Array-ify the type if necessary.
    const Type* type = baseType;
    if (arraySize > 0) {
        arraySize = type->convertArraySize(context, pos, pos, arraySize);
        if (!arraySize) {
            return nullptr;
        }
        type = context.fSymbolTable->addArrayDimension(context, type, arraySize);
    }
 
    // Error-check the interface block as if it were being declared as a global variable.
    VarDeclaration::ErrorCheck(context,
                               pos,
                               modifiers.fPosition,
                               modifiers.fLayout,
                               modifiers.fFlags,
                               type,
                               baseType,
                               VariableStorage::kGlobal);
 
    // Create a global variable for the Interface Block.
    std::unique_ptr<SkSL::Variable> var = SkSL::Variable::Convert(context,
                                                                  pos,
                                                                  modifiers.fPosition,
                                                                  modifiers.fLayout,
                                                                  modifiers.fFlags,
                                                                  type,
                                                                  pos,
                                                                  varName,
                                                                  VariableStorage::kGlobal);
    return InterfaceBlock::Make(context,
                                pos,
                                context.fSymbolTable->takeOwnershipOfSymbol(std::move(var)));
}

description()

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

overridevirtual

Implements SkSL::IRNode.

Definition at line 140 of file SkSLInterfaceBlock.cpp.

                                            {
    std::string result = this->var()->layout().description() +
                         this->var()->modifierFlags().description() + ' ' +
                         std::string(this->typeName()) + " {\n";
    const Type* structType = &this->var()->type();
    if (structType->isArray()) {
        structType = &structType->componentType();
    }
    for (const auto& f : structType->fields()) {
        result += f.description() + "\n";
    }
    result += "}";
    if (!this->instanceName().empty()) {
        result += " " + std::string(this->instanceName());
        if (this->arraySize() > 0) {
            String::appendf(&result, "[%d]", this->arraySize());
        }
    }
    return result + ";";
}

detachDeadVariable()

void SkSL::InterfaceBlock::detachDeadVariable ( )

inline

Definition at line 76 of file SkSLInterfaceBlock.h.

                              {
        fVariable = nullptr;
    }

instanceName()

std::string_view SkSL::InterfaceBlock::instanceName ( ) const

inline

Definition at line 84 of file SkSLInterfaceBlock.h.

                                        {
        return fVariable->name();
    }

Make()

std::unique_ptr< InterfaceBlock > SkSL::InterfaceBlock::Make ( const Context &  context, Position  pos, Variable *  variable  )

static

Definition at line 116 of file SkSLInterfaceBlock.cpp.

                                                                         {
    SkASSERT(ProgramConfig::IsFragment(context.fConfig->fKind) ||
             ProgramConfig::IsVertex(context.fConfig->fKind) ||
             ProgramConfig::IsCompute(context.fConfig->fKind));
 
    SkASSERT(variable->type().componentType().isInterfaceBlock());
    SkSpan<const Field> fields = variable->type().componentType().fields();
 
    if (variable->name().empty()) {
        // This interface block is anonymous. Add each field to the top-level symbol table.
        for (size_t i = 0; i < fields.size(); ++i) {
            context.fSymbolTable->add(
                    context, std::make_unique<SkSL::FieldSymbol>(fields[i].fPosition, variable, i));
        }
    } else {
        // Add the global variable to the top-level symbol table.
        context.fSymbolTable->addWithoutOwnership(context, variable);
    }
 
    return std::make_unique<SkSL::InterfaceBlock>(pos, variable);
}

typeName()

std::string_view SkSL::InterfaceBlock::typeName ( ) const

inline

Definition at line 80 of file SkSLInterfaceBlock.h.

                                    {
        return fVariable->type().componentType().name();
    }

var()

Variable * SkSL::InterfaceBlock::var ( ) const

inline

Definition at line 72 of file SkSLInterfaceBlock.h.

                          {
        return fVariable;
    }

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::InterfaceBlock::kIRNodeKind = Kind::kInterfaceBlock

inlinestaticconstexpr

Definition at line 40 of file SkSLInterfaceBlock.h.

---

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

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