skgpu::tess::FixedCountCurves Class Reference

#include <FixedCountBufferUtils.h>

Static Public Member Functions
static constexpr int	PreallocCount (int totalCombinedPathVerbCnt)
static int	VertexCount (const LinearTolerances &tolerances)
static constexpr size_t	VertexBufferSize ()
static constexpr size_t	IndexBufferSize ()
static void	WriteVertexBuffer (VertexWriter, size_t bufferSize)
static void	WriteIndexBuffer (VertexWriter, size_t bufferSize)

Detailed Description

Fixed-count tessellation operates in three modes, two for filling paths, and one for stroking. These modes may have additional sub-variations, but in terms of vertex buffer management, these three categories are sufficient:

• FixedCountCurves: for filling paths where just the curves are tessellated. Additional measures to fill space between the inner control points of the paths are needed.
• FixedCountWedges: for filling paths by tessellating the curves and adding an additional inline triangle with a shared vertex that all verbs connect to. Works with PatchAttribs::kFanPoint.
• FixedCountStrokes: for stroking a path. Likely paired with PatchAttribs::kJoinControlPoint and PatchAttribs::kStrokeParams.

The three types defined below for these three modes provide utility functions for heuristics to choose pre-allocation size when accumulating instance attributes with a PatchWriter, and functions for creating static/GPU-private vertex and index buffers that are used as the template for instanced rendering.

Definition at line 39 of file FixedCountBufferUtils.h.

Member Function Documentation

IndexBufferSize()

static constexpr size_t skgpu::tess::FixedCountCurves::IndexBufferSize ( )

inlinestaticconstexpr

Definition at line 66 of file FixedCountBufferUtils.h.

                                              {
        return NumCurveTrianglesAtResolveLevel(kMaxResolveLevel) * 3 * sizeof(uint16_t);
    }

PreallocCount()

static constexpr int skgpu::tess::FixedCountCurves::PreallocCount ( int  totalCombinedPathVerbCnt )

inlinestaticconstexpr

Definition at line 43 of file FixedCountBufferUtils.h.

                                                                     {
        // Over-allocate enough curves for 1 in 4 to chop. Every chop introduces 2 new patches:
        // another curve patch and a triangle patch that glues the two chops together,
        // i.e. + 2 * ((count + 3) / 4) == (count + 3) / 2
        return totalCombinedPathVerbCnt + (totalCombinedPathVerbCnt + 3) / 2;
    }

VertexBufferSize()

static constexpr size_t skgpu::tess::FixedCountCurves::VertexBufferSize ( )

inlinestaticconstexpr

Definition at line 61 of file FixedCountBufferUtils.h.

                                               {
        return (kMaxParametricSegments + 1) * (2 * sizeof(float));
    }

VertexCount()

static int skgpu::tess::FixedCountCurves::VertexCount ( const LinearTolerances &  tolerances )

inlinestatic

Definition at line 52 of file FixedCountBufferUtils.h.

                                                               {
        // We should already chopped curves to make sure none needed a higher resolveLevel than
        // kMaxResolveLevel.
        int resolveLevel = std::min(tolerances.requiredResolveLevel(), kMaxResolveLevel);
        return NumCurveTrianglesAtResolveLevel(resolveLevel) * 3;
    }

WriteIndexBuffer()

void skgpu::tess::FixedCountCurves::WriteIndexBuffer ( VertexWriter  vertexWriter, size_t  bufferSize  )

static

Definition at line 103 of file FixedCountBufferUtils.cpp.

                                                                                    {
   write_curve_index_buffer_base_index(std::move(vertexWriter), bufferSize, /*baseIndex=*/0);
}

WriteVertexBuffer()

void skgpu::tess::FixedCountCurves::WriteVertexBuffer ( VertexWriter  vertexWriter, size_t  bufferSize  )

static

Definition at line 70 of file FixedCountBufferUtils.cpp.

                                                                                     {
    SkASSERT(bufferSize >= sizeof(SkPoint) * 2);
    int vertexCount = bufferSize / sizeof(SkPoint);
    SkASSERT(vertexCount > 3);
    SkDEBUGCODE(auto end = vertexWriter.mark(vertexCount * sizeof(SkPoint));)
 
    // Lay out the vertices in "middle-out" order:
    //
    // T= 0/1, 1/1,              ; resolveLevel=0
    //    1/2,                   ; resolveLevel=1  (0/2 and 2/2 are already in resolveLevel 0)
    //    1/4, 3/4,              ; resolveLevel=2  (2/4 is already in resolveLevel 1)
    //    1/8, 3/8, 5/8, 7/8,    ; resolveLevel=3  (2/8 and 6/8 are already in resolveLevel 2)
    //    ...                    ; resolveLevel=...
    //
    // Resolve level 0 is just the beginning and ending vertices.
    vertexWriter << (float)0/*resolveLevel*/ << (float)0/*idx*/;
    vertexWriter << (float)0/*resolveLevel*/ << (float)1/*idx*/;
 
    // Resolve levels 1..kMaxResolveLevel.
    int maxResolveLevel = SkPrevLog2(vertexCount - 1);
    SkASSERT((1 << maxResolveLevel) + 1 == vertexCount);
    for (int resolveLevel = 1; resolveLevel <= maxResolveLevel; ++resolveLevel) {
        int numSegmentsInResolveLevel = 1 << resolveLevel;
        // Write out the odd vertices in this resolveLevel. The even vertices were already written
        // out in previous resolveLevels and will be indexed from there.
        for (int i = 1; i < numSegmentsInResolveLevel; i += 2) {
            vertexWriter << (float)resolveLevel << (float)i;
        }
    }
 
    SkASSERT(vertexWriter.mark() == end);
}

---

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

• third_party/skia/src/gpu/tessellate/FixedCountBufferUtils.h
• third_party/skia/src/gpu/tessellate/FixedCountBufferUtils.cpp