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

Detailed Description

Definition at line 1158 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 1161 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.
        // First, place the new-value components into the proper slots.
        fReintegrationSwizzle.resize(fullSlotCount);
        for (int index = 0; index < fComponents.size(); ++index) {
            fReintegrationSwizzle[fComponents[index]] = index;
        }
        // Then, refill the untouched slots with the original values.
        int originalValueComponentIndex = fComponents.size();
        for (int index = 0; index < fullSlotCount; ++index) {
            if (!used[index]) {
                fReintegrationSwizzle[index] = originalValueComponentIndex++;
            }
        }
    }

Member Function Documentation

◆ load()

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

inlineoverridevirtual

Implements SkSL::WGSLCodeGenerator::LValue.

Definition at line 1211 of file SkSLWGSLCodeGenerator.cpp.

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

◆ store()

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