skgpu::tess::LinearTolerances Class Reference

#include <LinearTolerances.h>

Public Member Functions
float	numParametricSegments_p4 () const
float	numRadialSegmentsPerRadian () const
int	numEdgesInJoins () const
int	requiredResolveLevel () const
int	requiredStrokeEdges () const
void	setParametricSegments (float n4)
void	setStroke (const StrokeParams &strokeParams, float maxScale)
void	accumulate (const LinearTolerances &tolerances)

Detailed Description

LinearTolerances stores state to approximate the final device-space transform applied to curves, and uses that to calculate segmentation levels for both the parametric curves and radial components (when stroking, where you have to represent the offset of a curve). These tolerances determine the worst-case number of parametric and radial segments required to accurately linearize curves.

• segments = a linear subsection on the curve, either defined as parametric (linear in t) or radial (linear in curve's internal rotation).
• edges = orthogonal geometry to segments, used in stroking to offset from the central curve by half the stroke width, or to construct the join geometry.

The tolerance values and decisions are estimated in the local path space, although PatchWriter uses a 2x2 vector transform that approximates the scale/skew (as-best-as-possible) of the full local-to-device transform applied in the vertex shader.

The properties tracked in LinearTolerances can be used to compute the final segmentation factor for filled paths (the resolve level) or stroked paths (the number of edges).

Definition at line 38 of file LinearTolerances.h.

Member Function Documentation

accumulate()

void skgpu::tess::LinearTolerances::accumulate ( const LinearTolerances &  tolerances )

inline

Definition at line 109 of file LinearTolerances.h.

                                                        {
        if (tolerances.fNumParametricSegments_p4 > fNumParametricSegments_p4) {
            fNumParametricSegments_p4 = tolerances.fNumParametricSegments_p4;
        }
        if (tolerances.fNumRadialSegmentsPerRadian > fNumRadialSegmentsPerRadian) {
            fNumRadialSegmentsPerRadian = tolerances.fNumRadialSegmentsPerRadian;
        }
        if (tolerances.fEdgesInJoins > fEdgesInJoins) {
            fEdgesInJoins = tolerances.fEdgesInJoins;
        }
    }

numEdgesInJoins()

int skgpu::tess::LinearTolerances::numEdgesInJoins ( ) const

inline

Definition at line 42 of file LinearTolerances.h.

{ return fEdgesInJoins; }

numParametricSegments_p4()

float skgpu::tess::LinearTolerances::numParametricSegments_p4 ( ) const

inline

Definition at line 40 of file LinearTolerances.h.

{ return fNumParametricSegments_p4; }

numRadialSegmentsPerRadian()

float skgpu::tess::LinearTolerances::numRadialSegmentsPerRadian ( ) const

inline

Definition at line 41 of file LinearTolerances.h.

{ return fNumRadialSegmentsPerRadian; }

requiredResolveLevel()

int skgpu::tess::LinearTolerances::requiredResolveLevel ( ) const

inline

Definition at line 45 of file LinearTolerances.h.

                                     {
        // log16(n^4) == log2(n)
        return wangs_formula::nextlog16(fNumParametricSegments_p4);
    }

requiredStrokeEdges()

int skgpu::tess::LinearTolerances::requiredStrokeEdges ( ) const

inline

Definition at line 50 of file LinearTolerances.h.

                                    {
        // The maximum rotation we can have in a stroke is 180 degrees (SK_ScalarPI radians).
        int maxRadialSegmentsInStroke =
                std::max(SkScalarCeilToInt(fNumRadialSegmentsPerRadian * SK_ScalarPI), 1);
 
        int maxParametricSegmentsInStroke =
                SkScalarCeilToInt(wangs_formula::root4(fNumParametricSegments_p4));
        SkASSERT(maxParametricSegmentsInStroke >= 1);
 
        // Now calculate the maximum number of edges we will need in the stroke portion of the
        // instance. The first and last edges in a stroke are shared by both the parametric and
        // radial sets of edges, so the total number of edges is:
        //
        //   numCombinedEdges = numParametricEdges + numRadialEdges - 2
        //
        // It's important to differentiate between the number of edges and segments in a strip:
        //
        //   numSegments = numEdges - 1
        //
        // So the total number of combined edges in the stroke is:
        //
        //   numEdgesInStroke = numParametricSegments + 1 + numRadialSegments + 1 - 2
        //                    = numParametricSegments + numRadialSegments
        //
        int maxEdgesInStroke = maxRadialSegmentsInStroke + maxParametricSegmentsInStroke;
 
        // Each triangle strip has two sections: It starts with a join then transitions to a
        // stroke. The number of edges in an instance is the sum of edges from the join and
        // stroke sections both.
        // NOTE: The final join edge and the first stroke edge are co-located, however we still
        // need to emit both because the join's edge is half-width and the stroke is full-width.
        return fEdgesInJoins + maxEdgesInStroke;
    }

setParametricSegments()

void skgpu::tess::LinearTolerances::setParametricSegments ( float  n4 )

inline

Definition at line 84 of file LinearTolerances.h.

                                         {
        SkASSERT(n4 >= 0.f);
        fNumParametricSegments_p4 = n4;
    }

setStroke()

void skgpu::tess::LinearTolerances::setStroke ( const StrokeParams &  strokeParams, float  maxScale  )

inline

Definition at line 89 of file LinearTolerances.h.

                                                                     {
        float approxDeviceStrokeRadius;
        if (strokeParams.fRadius == 0.f) {
            // Hairlines are always 1 px wide
            approxDeviceStrokeRadius = 0.5f;
        } else {
            // Approximate max scale * local stroke width / 2
            approxDeviceStrokeRadius = strokeParams.fRadius * maxScale;
        }
 
        fNumRadialSegmentsPerRadian = CalcNumRadialSegmentsPerRadian(approxDeviceStrokeRadius);
 
        fEdgesInJoins = NumFixedEdgesInJoin(strokeParams);
        if (strokeParams.fJoinType < 0.f && fNumRadialSegmentsPerRadian > 0.f) {
            // For round joins we need to count the radial edges on our own. Account for a
            // worst-case join of 180 degrees (SK_ScalarPI radians).
            fEdgesInJoins += SkScalarCeilToInt(fNumRadialSegmentsPerRadian * SK_ScalarPI) - 1;
        }
    }

---

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

• third_party/skia/src/gpu/tessellate/LinearTolerances.h