skgpu::graphite::CoverageMaskRenderStep Class Reference

#include <CoverageMaskRenderStep.h>

Inheritance diagram for skgpu::graphite::CoverageMaskRenderStep:

Public Member Functions
	CoverageMaskRenderStep ()
	~CoverageMaskRenderStep () override=default
std::string	vertexSkSL () const override
std::string	texturesAndSamplersSkSL (const ResourceBindingRequirements &, int *nextBindingIndex) const override
const char *	fragmentCoverageSkSL () const override
void	writeVertices (DrawWriter *, const DrawParams &, skvx::ushort2 ssboIndices) const override
void	writeUniformsAndTextures (const DrawParams &, PipelineDataGatherer *) const override
Public Member Functions inherited from skgpu::graphite::RenderStep
virtual	~RenderStep ()=default
virtual void	writeVertices (DrawWriter *, const DrawParams &, skvx::ushort2 ssboIndices) const =0
virtual void	writeUniformsAndTextures (const DrawParams &, PipelineDataGatherer *) const =0
virtual std::string	vertexSkSL () const =0
virtual std::string	texturesAndSamplersSkSL (const ResourceBindingRequirements &, int *nextBindingIndex) const
virtual const char *	fragmentCoverageSkSL () const
virtual const char *	fragmentColorSkSL () const
uint32_t	uniqueID () const
const char *	name () const
bool	requiresMSAA () const
bool	performsShading () const
bool	hasTextures () const
bool	emitsPrimitiveColor () const
bool	outsetBoundsForAA () const
Coverage	coverage () const
PrimitiveType	primitiveType () const
size_t	vertexStride () const
size_t	instanceStride () const
size_t	numUniforms () const
size_t	numVertexAttributes () const
size_t	numInstanceAttributes () const
SkSpan< const Uniform >	uniforms () const
SkSpan< const Attribute >	vertexAttributes () const
SkSpan< const Attribute >	instanceAttributes () const
SkSpan< const Varying >	varyings () const
const DepthStencilSettings &	depthStencilSettings () const
SkEnumBitMask< DepthStencilFlags >	depthStencilFlags () const

Additional Inherited Members
Static Public Member Functions inherited from skgpu::graphite::RenderStep
static const char *	ssboIndicesAttribute ()
static const char *	ssboIndicesVarying ()
Protected Types inherited from skgpu::graphite::RenderStep
enum class	Flags : unsigned {   kNone = 0b0000000 , kRequiresMSAA = 0b0000001 , kPerformsShading = 0b0000010 , kHasTextures = 0b0000100 ,   kEmitsCoverage = 0b0001000 , kLCDCoverage = 0b0010000 , kEmitsPrimitiveColor = 0b0100000 , kOutsetBoundsForAA = 0b1000000 }
Protected Member Functions inherited from skgpu::graphite::RenderStep
	RenderStep (std::string_view className, std::string_view variantName, SkEnumBitMask< Flags > flags, std::initializer_list< Uniform > uniforms, PrimitiveType primitiveType, DepthStencilSettings depthStencilSettings, SkSpan< const Attribute > vertexAttrs, SkSpan< const Attribute > instanceAttrs, SkSpan< const Varying > varyings={})

Detailed Description

Definition at line 15 of file CoverageMaskRenderStep.h.

Constructor & Destructor Documentation

CoverageMaskRenderStep()

skgpu::graphite::CoverageMaskRenderStep::CoverageMaskRenderStep

(

)

Definition at line 38 of file CoverageMaskRenderStep.cpp.

        : RenderStep("CoverageMaskRenderStep",
                     "",
                     // The mask will have AA outsets baked in, but the original bounds for clipping
                     // still require the outset for analytic coverage.
                     Flags::kPerformsShading | Flags::kHasTextures | Flags::kEmitsCoverage |
                     Flags::kOutsetBoundsForAA,
                     /*uniforms=*/{{"maskToDeviceRemainder", SkSLType::kFloat3x3}},
                     PrimitiveType::kTriangleStrip,
                     kDirectDepthGreaterPass,
                     /*vertexAttrs=*/{},
                     /*instanceAttrs=*/
                     // Draw bounds and mask bounds are in normalized relative to the mask texture,
                     // but 'drawBounds' is stored in float since the coords may map outside of
                     // [0,1] for inverse-filled masks. 'drawBounds' is relative to the logical mask
                     // entry's origin, while 'maskBoundsIn' is atlas-relative. Inverse fills swap
                     // the order in 'maskBoundsIn' to be RBLT.
                     {{"drawBounds", VertexAttribType::kFloat4 , SkSLType::kFloat4},  // ltrb
                      {"maskBoundsIn", VertexAttribType::kUShort4_norm, SkSLType::kFloat4},
                      // Remaining translation extracted from actual 'maskToDevice' transform.
                      {"deviceOrigin", VertexAttribType::kFloat2, SkSLType::kFloat2},
                      {"depth"     , VertexAttribType::kFloat, SkSLType::kFloat},
                      {"ssboIndices", VertexAttribType::kUShort2, SkSLType::kUShort2},
                      // deviceToLocal matrix for producing local coords for shader evaluation
                      {"mat0", VertexAttribType::kFloat3, SkSLType::kFloat3},
                      {"mat1", VertexAttribType::kFloat3, SkSLType::kFloat3},
                      {"mat2", VertexAttribType::kFloat3, SkSLType::kFloat3}},
                     /*varyings=*/
                     {// `maskBounds` are the atlas-relative, sorted bounds of the coverage mask.
                      // `textureCoords` are the atlas-relative UV coordinates of the draw, which
                      // can spill beyond `maskBounds` for inverse fills.
                      // TODO: maskBounds is constant for all fragments for a given instance,
                      // could we store them in the draw's SSBO?
                      {"maskBounds"   , SkSLType::kFloat4},
                      {"textureCoords", SkSLType::kFloat2},
                      // 'invert' is set to 0 use unmodified coverage, and set to 1 for "1-c".
                      {"invert", SkSLType::kHalf}}) {}

~CoverageMaskRenderStep()

skgpu::graphite::CoverageMaskRenderStep::~CoverageMaskRenderStep ( )

overridedefault

Member Function Documentation

fragmentCoverageSkSL()

const char * skgpu::graphite::CoverageMaskRenderStep::fragmentCoverageSkSL ( ) const

overridevirtual

Reimplemented from skgpu::graphite::RenderStep.

Definition at line 91 of file CoverageMaskRenderStep.cpp.

                                                               {
    return R"(
        half c = sample(pathAtlas, clamp(textureCoords, maskBounds.LT, maskBounds.RB)).r;
        outputCoverage = half4(mix(c, 1 - c, invert));
    )";
}

texturesAndSamplersSkSL()

std::string skgpu::graphite::CoverageMaskRenderStep::texturesAndSamplersSkSL ( const ResourceBindingRequirements &  bindingReqs, int *  nextBindingIndex  ) const

overridevirtual

Reimplemented from skgpu::graphite::RenderStep.

Definition at line 86 of file CoverageMaskRenderStep.cpp.

                                                                                     {
    return EmitSamplerLayout(bindingReqs, nextBindingIndex) + " sampler2D pathAtlas;";
}

vertexSkSL()

std::string skgpu::graphite::CoverageMaskRenderStep::vertexSkSL ( ) const

overridevirtual

Implements skgpu::graphite::RenderStep.

Definition at line 76 of file CoverageMaskRenderStep.cpp.

                                                   {
    // Returns the body of a vertex function, which must define a float4 devPosition variable and
    // must write to an already-defined float2 stepLocalCoords variable.
    return "float4 devPosition = coverage_mask_vertex_fn("
                    "float2(sk_VertexID >> 1, sk_VertexID & 1), "
                    "maskToDeviceRemainder, drawBounds, maskBoundsIn, deviceOrigin, "
                    "depth, float3x3(mat0, mat1, mat2), "
                    "maskBounds, textureCoords, invert, stepLocalCoords);\n";
}

writeUniformsAndTextures()

void skgpu::graphite::CoverageMaskRenderStep::writeUniformsAndTextures ( const DrawParams &  params, PipelineDataGatherer *  gatherer  ) const

overridevirtual

Implements skgpu::graphite::RenderStep.

Definition at line 186 of file CoverageMaskRenderStep.cpp.

                                                                                            {
    SkDEBUGCODE(UniformExpectationsValidator uev(gatherer, this->uniforms());)
 
    const CoverageMaskShape& coverageMask = params.geometry().coverageMaskShape();
    const TextureProxy* proxy = coverageMask.textureProxy();
    SkASSERT(proxy);
 
    // Most coverage masks are aligned with the device pixels, so the params' transform is an
    // integer translation matrix. This translation is extracted as an instance attribute so that
    // the remaining transform has a much lower frequency of changing (only complex-transformed
    // mask filters).
    skvx::float2 deviceOrigin = get_device_translation(params.transform().matrix());
    SkMatrix maskToDevice = params.transform().matrix().asM33();
    maskToDevice.preTranslate(-deviceOrigin.x(), -deviceOrigin.y());
 
    // The mask coordinates in the vertex shader will be normalized, so scale by the proxy size
    // to get back to Skia's texel-based coords.
    maskToDevice.preScale(proxy->dimensions().width(), proxy->dimensions().height());
 
    // Write uniforms:
    gatherer->write(maskToDevice);
 
    // Write textures and samplers:
    const bool pixelAligned =
            params.transform().type() <= Transform::Type::kSimpleRectStaysRect &&
            params.transform().maxScaleFactor() == 1.f &&
            all(deviceOrigin == floor(deviceOrigin + SK_ScalarNearlyZero));
    constexpr SkTileMode kTileModes[2] = {SkTileMode::kClamp, SkTileMode::kClamp};
    gatherer->add(sk_ref_sp(proxy),
                  {pixelAligned ? SkFilterMode::kNearest : SkFilterMode::kLinear, kTileModes});
}

writeVertices()

void skgpu::graphite::CoverageMaskRenderStep::writeVertices ( DrawWriter *  dw, const DrawParams &  params, skvx::ushort2  ssboIndices  ) const

overridevirtual

Implements skgpu::graphite::RenderStep.

Definition at line 98 of file CoverageMaskRenderStep.cpp.

                                                                          {
    const CoverageMaskShape& coverageMask = params.geometry().coverageMaskShape();
    const TextureProxy* proxy = coverageMask.textureProxy();
    SkASSERT(proxy);
 
    // A quad is a 4-vertex instance. The coordinates are derived from the vertex IDs.
    DrawWriter::Instances instances(*dw, {}, {}, 4);
 
    // The device origin is the  translation extracted from the mask-to-device matrix so
    // that the remaining matrix uniform has less variance between draws.
    const auto& maskToDevice = params.transform().matrix();
    skvx::float2 deviceOrigin = get_device_translation(maskToDevice);
 
    // Relative to mask space (device origin and mask-to-device remainder must be applied in shader)
    skvx::float4 maskBounds = coverageMask.bounds().ltrb();
    skvx::float4 drawBounds;
 
    if (coverageMask.inverted()) {
        // Only mask filters trigger complex transforms, and they are never inverse filled. Since
        // we know this is an inverted mask, then we can exactly map the draw's clip bounds to mask
        // space so that the clip is still fully covered without branching in the vertex shader.
        SkASSERT(maskToDevice == SkM44::Translate(deviceOrigin.x(), deviceOrigin.y()));
        drawBounds = params.clip().drawBounds().makeOffset(-deviceOrigin).ltrb();
 
        // If the mask is fully clipped out, then the shape's mask info should be (0,0,0,0).
        // If it's not fully clipped out, then the mask info should be non-empty.
        SkASSERT(!params.clip().transformedShapeBounds().isEmptyNegativeOrNaN() ^
                 all(maskBounds == 0.f));
 
        if (params.clip().transformedShapeBounds().isEmptyNegativeOrNaN()) {
            // The inversion check is strict inequality, so (0,0,0,0) would not be detected. Adjust
            // to (0,0,1/2,1/2) to restrict sampling to the top-left quarter of the top-left pixel,
            // which should have a value of 0 regardless of filtering mode.
            maskBounds = skvx::float4{0.f, 0.f, 0.5f, 0.5f};
        } else {
            // Add 1/2px outset to the mask bounds so that clamped coordinates sample the texel
            // center of the padding around the atlas entry.
            maskBounds += skvx::float4{-0.5f, -0.5f, 0.5f, 0.5f};
        }
 
        // and store RBLT so that the 'maskBoundsIn' attribute has xy > zw to detect inverse fill.
        maskBounds = skvx::shuffle<2,3,0,1>(maskBounds);
    } else {
        // If we aren't inverted, then the originally assigned values don't need to be adjusted, but
        // also ensure the mask isn't empty (otherwise the draw should have been skipped earlier).
        SkASSERT(!coverageMask.bounds().isEmptyNegativeOrNaN());
        SkASSERT(all(maskBounds.xy() < maskBounds.zw()));
 
        // Since the mask bounds and draw bounds are 1-to-1 with each other, the clamping of texture
        // coords is mostly a formality. We inset the mask bounds by 1/2px so that we clamp to the
        // texel center of the outer row/column of the mask. This should be a no-op for nearest
        // sampling but prevents any linear sampling from incorporating adjacent data; for atlases
        // this would just be 0 but for non-atlas coverage masks that might not have padding this
        // avoids filtering unknown values in an approx-fit texture.
        drawBounds = maskBounds;
        maskBounds -= skvx::float4{-0.5f, -0.5f, 0.5f, 0.5f};
    }
 
    // Move 'drawBounds' and 'maskBounds' into the atlas coordinate space, then adjust the
    // device translation to undo the atlas origin automatically in the vertex shader.
    skvx::float2 textureOrigin = skvx::cast<float>(coverageMask.textureOrigin());
    maskBounds += textureOrigin.xyxy();
    drawBounds += textureOrigin.xyxy();
    deviceOrigin -= textureOrigin;
 
    // Normalize drawBounds and maskBounds after possibly correcting drawBounds for inverse fills.
    // The maskToDevice matrix uniform will handle de-normalizing drawBounds for vertex positions.
    auto atlasSizeInv = skvx::float2{1.f / proxy->dimensions().width(),
                                     1.f / proxy->dimensions().height()};
    drawBounds *= atlasSizeInv.xyxy();
    maskBounds *= atlasSizeInv.xyxy();
    deviceOrigin *= atlasSizeInv;
 
    // Since the mask bounds define normalized texels of the texture, we can encode them as
    // ushort_norm without losing precision to save space.
    SkASSERT(all((maskBounds >= 0.f) & (maskBounds <= 1.f)));
    maskBounds = 65535.f * maskBounds + 0.5f;
 
    const SkM44& m = coverageMask.deviceToLocal();
    instances.append(1) << drawBounds << skvx::cast<uint16_t>(maskBounds) << deviceOrigin
                        << params.order().depthAsFloat() << ssboIndices
                        << m.rc(0,0) << m.rc(1,0) << m.rc(3,0)   // mat0
                        << m.rc(0,1) << m.rc(1,1) << m.rc(3,1)   // mat1
                        << m.rc(0,3) << m.rc(1,3) << m.rc(3,3);  // mat2
}

---

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

• third_party/skia/src/gpu/graphite/render/CoverageMaskRenderStep.h
• third_party/skia/src/gpu/graphite/render/CoverageMaskRenderStep.cpp