#include <TessellateStrokesRenderStep.h>

Inheritance diagram for skgpu::graphite::TessellateStrokesRenderStep:

Public Member Functions
	TessellateStrokesRenderStep (bool infinitySupport)

	~TessellateStrokesRenderStep () override

std::string	vertexSkSL () 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 TessellateStrokesRenderStep.h.

Constructor & Destructor Documentation

◆ TessellateStrokesRenderStep()

skgpu::graphite::TessellateStrokesRenderStep::TessellateStrokesRenderStep ( bool infinitySupport )

explicit

Definition at line 78 of file TessellateStrokesRenderStep.cpp.

        : RenderStep("TessellateStrokeRenderStep",
                     "",
                     Flags::kRequiresMSAA | Flags::kPerformsShading,
                     /*uniforms=*/{{"affineMatrix", SkSLType::kFloat4},
                                   {"translate", SkSLType::kFloat2},
                                   {"maxScale", SkSLType::kFloat}},
                     PrimitiveType::kTriangleStrip,
                     kDirectDepthGreaterPass,
                     /*vertexAttrs=*/  {},
                     /*instanceAttrs=*/kAttributes[infinitySupport])
        , fInfinitySupport(infinitySupport) {}

◆ ~TessellateStrokesRenderStep()

skgpu::graphite::TessellateStrokesRenderStep::~TessellateStrokesRenderStep ( )

override

Definition at line 91 of file TessellateStrokesRenderStep.cpp.

91{}

Member Function Documentation

◆ vertexSkSL()

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

overridevirtual

Implements skgpu::graphite::RenderStep.

Definition at line 93 of file TessellateStrokesRenderStep.cpp.

                                                        {
    // TODO: Assumes vertex ID support for now, max edges must equal
    // skgpu::tess::FixedCountStrokes::kMaxEdges -> (2^14 - 1) -> 16383
    return SkSL::String::printf(
            R"(
                float edgeID = float(sk_VertexID >> 1);
                if ((sk_VertexID & 1) != 0) {

◆ writeUniformsAndTextures()

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

overridevirtual

Implements skgpu::graphite::RenderStep.

Definition at line 230 of file TessellateStrokesRenderStep.cpp.

                           {
                        writer.writeCubic(chops);
                        writer.writeCubic(chops + 3);
                        writer.writeCubic(chops + 6);
                    }
                }
                break;
        }
    }
}
 
void TessellateStrokesRenderStep::writeUniformsAndTextures(const DrawParams& params,
                                                           PipelineDataGatherer* gatherer) const {
    // TODO: Implement perspective
    SkASSERT(params.transform().type() < Transform::Type::kPerspective);
 
    SkDEBUGCODE(UniformExpectationsValidator uev(gatherer, this->uniforms());)
 

◆ writeVertices()

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

overridevirtual

Implements skgpu::graphite::RenderStep.

Definition at line 101 of file TessellateStrokesRenderStep.cpp.

                                                                   : "curveType");
}
 
void TessellateStrokesRenderStep::writeVertices(DrawWriter* dw,
                                                const DrawParams& params,
                                                skvx::ushort2 ssboIndices) const {
    SkPath path = params.geometry().shape().asPath(); // TODO: Iterate the Shape directly
 
    int patchReserveCount = FixedCountStrokes::PreallocCount(path.countVerbs());
    // Stroke tessellation does not use fixed indices or vertex data, and only needs the vertex ID
    static const BindBufferInfo kNullBinding = {};
    // TODO: All HW that Graphite will run on should support instancing ith sk_VertexID, but when
    // we support Vulkan+Swiftshader, we will need the vertex buffer ID fallback unless Swiftshader
    // has figured out how to support vertex IDs before then.
    Writer writer{fInfinitySupport ? kAttribs : kAttribsWithCurveType,
                  *dw,
                  kNullBinding,
                  kNullBinding,
                  patchReserveCount};
    writer.updatePaintDepthAttrib(params.order().depthAsFloat());
    writer.updateSsboIndexAttrib(ssboIndices);
 
    // The vector xform approximates how the control points are transformed by the shader to
    // more accurately compute how many *parametric* segments are needed.
    // getMaxScale() returns -1 if it can't compute a scale factor (e.g. perspective), taking the
    // absolute value automatically converts that to an identity scale factor for our purposes.
    writer.setShaderTransform(wangs_formula::VectorXform{params.transform().matrix()},
                              params.transform().maxScaleFactor());
 
    SkASSERT(params.isStroke());
    writer.updateStrokeParamsAttrib({params.strokeStyle().halfWidth(),
                                     params.strokeStyle().joinLimit()});
 
    // TODO: If PatchWriter can handle adding caps to its deferred patches, and we can convert
    // hairlines to use round caps instead of square, then StrokeIterator can be deleted entirely.
    // Besides being simpler, PatchWriter already has what it needs from the shader matrix and
    // stroke params, so we don't have to re-extract them here.
    SkMatrix shaderMatrix = params.transform();
    SkStrokeRec stroke{SkStrokeRec::kHairline_InitStyle};
    stroke.setStrokeStyle(params.strokeStyle().width());
    stroke.setStrokeParams(params.strokeStyle().cap(),
                           params.strokeStyle().join(),
                           params.strokeStyle().miterLimit());
    StrokeIterator strokeIter(path, &stroke, &shaderMatrix);
    while (strokeIter.next()) {
        using Verb = StrokeIterator::Verb;
        const SkPoint* p = strokeIter.pts();
        int numChops;
 
        // TODO: The cusp detection logic should be moved into PatchWriter and shared between
        // this and StrokeTessellator.cpp, but that will require updating a lot of SkGeometry to
        // operate on float2 (skvx) instead of the legacy SkNx or SkPoint.
        switch (strokeIter.verb()) {
            case Verb::kContourFinished:
                writer.writeDeferredStrokePatch();
                break;
            case Verb::kCircle:
                // Round cap or else an empty stroke that is specified to be drawn as a circle.
                writer.writeCircle(p[0]);
                [[fallthrough]];
            case Verb::kMoveWithinContour:
                // A regular kMove invalidates the previous control point; the stroke iterator
                // tells us a new value to use.
                writer.updateJoinControlPointAttrib(p[0]);
                break;
            case Verb::kLine:
                writer.writeLine(p[0], p[1]);
                break;
            case Verb::kQuad:
                if (ConicHasCusp(p)) {
                    // The cusp is always at the midtandent.
                    SkPoint cusp = SkEvalQuadAt(p, SkFindQuadMidTangent(p));
                    writer.writeCircle(cusp);
                    // A quad can only have a cusp if it's flat with a 180-degree turnaround.
                    writer.writeLine(p[0], cusp);
                    writer.writeLine(cusp, p[2]);
                } else {
                    writer.writeQuadratic(p);
                }
                break;
            case Verb::kConic:
                if (ConicHasCusp(p)) {
                    // The cusp is always at the midtandent.
                    SkConic conic(p, strokeIter.w());
                    SkPoint cusp = conic.evalAt(conic.findMidTangent());
                    writer.writeCircle(cusp);
                    // A conic can only have a cusp if it's flat with a 180-degree turnaround.
                    writer.writeLine(p[0], cusp);
                    writer.writeLine(cusp, p[2]);
                } else {
                    writer.writeConic(p, strokeIter.w());
                }
                break;
            case Verb::kCubic:
                SkPoint chops[10];
                float T[2];
                bool areCusps;
                numChops = FindCubicConvex180Chops(p, T, &areCusps);
                if (numChops == 0) {
                    writer.writeCubic(p);
                } else if (numChops == 1) {
                    SkChopCubicAt(p, chops, T[0]);
                    if (areCusps) {
                        writer.writeCircle(chops[3]);
                        // In a perfect world, these 3 points would be be equal after chopping
                        // on a cusp.
                        chops[2] = chops[4] = chops[3];
                    }
                    writer.writeCubic(chops);
                    writer.writeCubic(chops + 3);
                } else {
                    SkASSERT(numChops == 2);
                    SkChopCubicAt(p, chops, T[0], T[1]);
                    if (areCusps) {
                        writer.writeCircle(chops[3]);
                        writer.writeCircle(chops[6]);
                        // Two cusps are only possible if it's a flat line with two 180-degree
                        // turnarounds.
                        writer.writeLine(chops[0], chops[3]);
                        writer.writeLine(chops[3], chops[6]);

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

third_party/skia/src/gpu/graphite/render/TessellateStrokesRenderStep.h
third_party/skia/src/gpu/graphite/render/TessellateStrokesRenderStep.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TessellateStrokesRenderStep()

◆ ~TessellateStrokesRenderStep()

Member Function Documentation

◆ vertexSkSL()

◆ writeUniformsAndTextures()

◆ writeVertices()