SkSL::WGSLCodeGenerator::SwizzleLValue Class Reference

Inheritance diagram for SkSL::WGSLCodeGenerator::SwizzleLValue:

Public Member Functions
	SwizzleLValue (const Context &ctx, std::string name, const Type &t, const ComponentArray &c)
std::string	load () override
std::string	store (const std::string &value) override
Public Member Functions inherited from SkSL::WGSLCodeGenerator::LValue
virtual	~LValue ()=default
virtual std::string	load ()=0
virtual std::string	store (const std::string &value)=0

Detailed Description

Definition at line 1160 of file SkSLWGSLCodeGenerator.cpp.

Constructor & Destructor Documentation

SwizzleLValue()

SkSL::WGSLCodeGenerator::SwizzleLValue::SwizzleLValue ( const Context &  ctx, std::string  name, const Type &  t, const ComponentArray &  c  )

inline

Definition at line 1163 of file SkSLWGSLCodeGenerator.cpp.

            : fContext(ctx)
            , fName(std::move(name))
            , fType(t)
            , fComponents(c) {
        // If the component array doesn't cover the entire value, we need to create masks for
        // writing back into the lvalue. For example, if the type is vec4 and the component array
        // holds `zx`, a GLSL assignment would look like:
        //     name.zx = new_value;
        //
        // The equivalent WGSL assignment statement would look like:
        //     name = vec4<f32>(new_value, name.xw).yzxw;
        //
        // This replaces name.zy with new_value.xy, and leaves name.xw at their original values.
        // By convention, we always put the new value first and the original values second; it might
        // be possible to find better arrangements which simplify the assignment overall, but we
        // don't attempt this.
        int fullSlotCount = fType.slotCount();
        SkASSERT(fullSlotCount <= 4);
 
        // First, see which components are used.
        // The assignment swizzle must not reuse components.
        bool used[4] = {};
        for (int8_t component : fComponents) {
            SkASSERT(!used[component]);
            used[component] = true;
        }
 
        // Any untouched components will need to be fetched from the original value.
        for (int index = 0; index < fullSlotCount; ++index) {
            if (!used[index]) {
                fUntouchedComponents.push_back(index);
            }
        }
 
        // The reintegration swizzle needs to move the components back into their proper slots.
        fReintegrationSwizzle.resize(fullSlotCount);
        int reintegrateIndex = 0;
 
        // This refills the untouched slots with the original values.
        auto refillUntouchedSlots = [&] {
            for (int index = 0; index < fullSlotCount; ++index) {
                if (!used[index]) {
                    fReintegrationSwizzle[index] = reintegrateIndex++;
                }
            }
        };
 
        // This places the new-value components into the proper slots.
        auto insertNewValuesIntoSlots = [&] {
            for (int index = 0; index < fComponents.size(); ++index) {
                fReintegrationSwizzle[fComponents[index]] = reintegrateIndex++;
            }
        };
 
        // When reintegrating the untouched and new values, if the `x` slot is overwritten, we
        // reintegrate the new value first. Otherwise, we reintegrate the original value first.
        // This increases our odds of getting an identity swizzle for the reintegration.
        if (used[0]) {
            fReintegrateNewValueFirst = true;
            insertNewValuesIntoSlots();
            refillUntouchedSlots();
        } else {
            fReintegrateNewValueFirst = false;
            refillUntouchedSlots();
            insertNewValuesIntoSlots();
        }
    }

Member Function Documentation

load()

std::string SkSL::WGSLCodeGenerator::SwizzleLValue::load ( )

inlineoverridevirtual

Implements SkSL::WGSLCodeGenerator::LValue.

Definition at line 1232 of file SkSLWGSLCodeGenerator.cpp.

                              {
        return fName + "." + Swizzle::MaskString(fComponents);
    }

store()

std::string SkSL::WGSLCodeGenerator::SwizzleLValue::store ( const std::string &  value )

inlineoverridevirtual

Implements SkSL::WGSLCodeGenerator::LValue.

Definition at line 1236 of file SkSLWGSLCodeGenerator.cpp.

                                                     {
        // `variable = `
        std::string result = fName;
        result += " = ";
 
        if (fUntouchedComponents.empty()) {
            // `(new_value);`
            result += '(';
            result += value;
            result += ")";
        } else if (fReintegrateNewValueFirst) {
            // `vec4<f32>((new_value), `
            result += to_wgsl_type(fContext, fType);
            result += "((";
            result += value;
            result += "), ";
 
            // `variable.yz)`
            result += fName;
            result += '.';
            result += Swizzle::MaskString(fUntouchedComponents);
            result += ')';
        } else {
            // `vec4<f32>(variable.yz`
            result += to_wgsl_type(fContext, fType);
            result += '(';
            result += fName;
            result += '.';
            result += Swizzle::MaskString(fUntouchedComponents);
 
            // `, (new_value))`
            result += ", (";
            result += value;
            result += "))";
        }
 
        if (!Swizzle::IsIdentity(fReintegrationSwizzle)) {
            // `.wzyx`
            result += '.';
            result += Swizzle::MaskString(fReintegrationSwizzle);
        }
 
        return result + ';';
    }

---

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

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