SkSL::SwizzleLValue Class Reference

Inheritance diagram for SkSL::SwizzleLValue:

Public Member Functions
	SwizzleLValue (SPIRVCodeGenerator &gen, SpvId vecPointer, const ComponentArray &components, const Type &baseType, const Type &swizzleType, SpvStorageClass_ storageClass)
bool	applySwizzle (const ComponentArray &components, const Type &newType) override
SpvStorageClass	storageClass () const override
SpvId	load (OutputStream &out) override
void	store (SpvId value, OutputStream &out) override
Public Member Functions inherited from SkSL::SPIRVCodeGenerator::LValue
virtual	~LValue ()
virtual SpvId	getPointer ()
virtual bool	isMemoryObjectPointer () const

Detailed Description

Definition at line 3097 of file SkSLSPIRVCodeGenerator.cpp.

Constructor & Destructor Documentation

SwizzleLValue()

SkSL::SwizzleLValue::SwizzleLValue ( SPIRVCodeGenerator &  gen, SpvId  vecPointer, const ComponentArray &  components, const Type &  baseType, const Type &  swizzleType, SpvStorageClass_  storageClass  )

inline

Definition at line 3099 of file SkSLSPIRVCodeGenerator.cpp.

    : fGen(gen)
    , fVecPointer(vecPointer)
    , fComponents(components)
    , fBaseType(&baseType)
    , fSwizzleType(&swizzleType)
    , fStorageClass(storageClass) {}

Member Function Documentation

applySwizzle()

bool SkSL::SwizzleLValue::applySwizzle ( const ComponentArray &  components, const Type &  newType  )

inlineoverridevirtual

Reimplemented from SkSL::SPIRVCodeGenerator::LValue.

Definition at line 3108 of file SkSLSPIRVCodeGenerator.cpp.

                                                                                      {
        ComponentArray updatedSwizzle;
        for (int8_t component : components) {
            if (component < 0 || component >= fComponents.size()) {
                SkDEBUGFAILF("swizzle accessed nonexistent component %d", (int)component);
                return false;
            }
            updatedSwizzle.push_back(fComponents[component]);
        }
        fComponents = updatedSwizzle;
        fSwizzleType = &newType;
        return true;
    }

load()

SpvId SkSL::SwizzleLValue::load ( OutputStream &  out )

inlineoverridevirtual

Implements SkSL::SPIRVCodeGenerator::LValue.

Definition at line 3126 of file SkSLSPIRVCodeGenerator.cpp.

                                           {
        SpvId base = fGen.nextId(fBaseType);
        fGen.writeInstruction(SpvOpLoad, fGen.getType(*fBaseType), base, fVecPointer, out);
        SpvId result = fGen.nextId(fBaseType);
        fGen.writeOpCode(SpvOpVectorShuffle, 5 + (int32_t) fComponents.size(), out);
        fGen.writeWord(fGen.getType(*fSwizzleType), out);
        fGen.writeWord(result, out);
        fGen.writeWord(base, out);
        fGen.writeWord(base, out);
        for (int component : fComponents) {
            fGen.writeWord(component, out);
        }
        return result;
    }

storageClass()

SpvStorageClass SkSL::SwizzleLValue::storageClass ( ) const

inlineoverridevirtual

Implements SkSL::SPIRVCodeGenerator::LValue.

Definition at line 3122 of file SkSLSPIRVCodeGenerator.cpp.

                                                  {
        return fStorageClass;
    }

store()

void SkSL::SwizzleLValue::store ( SpvId  value, OutputStream &  out  )

inlineoverridevirtual

Implements SkSL::SPIRVCodeGenerator::LValue.

Definition at line 3141 of file SkSLSPIRVCodeGenerator.cpp.

                                                        {
        // use OpVectorShuffle to mix and match the vector components. We effectively create
        // a virtual vector out of the concatenation of the left and right vectors, and then
        // select components from this virtual vector to make the result vector. For
        // instance, given:
        // float3L = ...;
        // float3R = ...;
        // L.xz = R.xy;
        // we end up with the virtual vector (L.x, L.y, L.z, R.x, R.y, R.z). Then we want
        // our result vector to look like (R.x, L.y, R.y), so we need to select indices
        // (3, 1, 4).
        SpvId base = fGen.nextId(fBaseType);
        fGen.writeInstruction(SpvOpLoad, fGen.getType(*fBaseType), base, fVecPointer, out);
        SpvId shuffle = fGen.nextId(fBaseType);
        fGen.writeOpCode(SpvOpVectorShuffle, 5 + fBaseType->columns(), out);
        fGen.writeWord(fGen.getType(*fBaseType), out);
        fGen.writeWord(shuffle, out);
        fGen.writeWord(base, out);
        fGen.writeWord(value, out);
        for (int i = 0; i < fBaseType->columns(); i++) {
            // current offset into the virtual vector, defaults to pulling the unmodified
            // value from the left side
            int offset = i;
            // check to see if we are writing this component
            for (int j = 0; j < fComponents.size(); j++) {
                if (fComponents[j] == i) {
                    // we're writing to this component, so adjust the offset to pull from
                    // the correct component of the right side instead of preserving the
                    // value from the left
                    offset = (int) (j + fBaseType->columns());
                    break;
                }
            }
            fGen.writeWord(offset, out);
        }
        fGen.writeOpStore(fStorageClass, fVecPointer, shuffle, out);
    }

---

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

• third_party/skia/src/sksl/codegen/SkSLSPIRVCodeGenerator.cpp