skgpu::ganesh::QuadPerEdgeAA Namespace Reference

Classes
class	QuadPerEdgeAAGeometryProcessor
class	Tessellator
struct	VertexSpec

Typedefs
using	Saturate = skgpu::ganesh::TextureOp::Saturate

Enumerations
enum class	CoverageMode { kNone , kWithPosition , kWithColor }
enum class	Subset : bool { kNo = false , kYes = true }
enum class	ColorType { kNone , kByte , kFloat , kLast = kFloat }
enum class	IndexBufferOption { kPictureFramed , kIndexedRects , kTriStrips , kLast = kTriStrips }

Functions
IndexBufferOption	CalcIndexBufferOption (GrAAType aa, int numQuads)
ColorType	MinColorType (SkPMColor4f color)
sk_sp< const GrBuffer >	GetIndexBuffer (GrMeshDrawTarget *target, IndexBufferOption indexBufferOption)
int	QuadLimit (IndexBufferOption option)
void	IssueDraw (const GrCaps &caps, GrOpsRenderPass *renderPass, const VertexSpec &spec, int runningQuadCount, int quadsInDraw, int maxVerts, int absVertBufferOffset)
GrGeometryProcessor *	MakeProcessor (SkArenaAlloc *arena, const VertexSpec &spec)
GrGeometryProcessor *	MakeTexturedProcessor (SkArenaAlloc *arena, const VertexSpec &spec, const GrShaderCaps &caps, const GrBackendFormat &backendFormat, GrSamplerState samplerState, const skgpu::Swizzle &swizzle, sk_sp< GrColorSpaceXform > textureColorSpaceXform, Saturate saturate)

Variables
static const int	kColorTypeCount = static_cast<int>(ColorType::kLast) + 1
static const int	kIndexBufferOptionCount = static_cast<int>(IndexBufferOption::kLast) + 1

Typedef Documentation

Saturate

using skgpu::ganesh::QuadPerEdgeAA::Saturate = typedef skgpu::ganesh::TextureOp::Saturate

Definition at line 30 of file QuadPerEdgeAA.h.

Enumeration Type Documentation

ColorType

enum class skgpu::ganesh::QuadPerEdgeAA::ColorType

strong

Enumerator
kNone
kByte
kFloat
kLast

Definition at line 34 of file QuadPerEdgeAA.h.

{ kNone, kByte, kFloat, kLast = kFloat };

CoverageMode

enum class skgpu::ganesh::QuadPerEdgeAA::CoverageMode

strong

Enumerator
kNone
kWithPosition
kWithColor

Definition at line 32 of file QuadPerEdgeAA.h.

{ kNone, kWithPosition, kWithColor };

IndexBufferOption

enum class skgpu::ganesh::QuadPerEdgeAA::IndexBufferOption

strong

Enumerator
kPictureFramed
kIndexedRects
kTriStrips
kLast

Definition at line 37 of file QuadPerEdgeAA.h.

                             {
    kPictureFramed,  // geometrically AA'd   -> 8 verts/quad + an index buffer
    kIndexedRects,   // non-AA'd but indexed -> 4 verts/quad + an index buffer
    kTriStrips,      // non-AA'd             -> 4 verts/quad but no index buffer
    kLast = kTriStrips
};

Subset

enum class skgpu::ganesh::QuadPerEdgeAA::Subset : bool

strong

Enumerator
kNo
kYes

Definition at line 33 of file QuadPerEdgeAA.h.

: bool { kNo = false, kYes = true };

Function Documentation

CalcIndexBufferOption()

IndexBufferOption skgpu::ganesh::QuadPerEdgeAA::CalcIndexBufferOption	(	GrAAType	aa,
		int	numQuads
	)

Definition at line 305 of file QuadPerEdgeAA.cpp.

                                                                   {
    if (aa == GrAAType::kCoverage) {
        return IndexBufferOption::kPictureFramed;
    } else if (numQuads > 1) {
        return IndexBufferOption::kIndexedRects;
    } else {
        return IndexBufferOption::kTriStrips;
    }
}

GetIndexBuffer()

sk_sp< const GrBuffer > skgpu::ganesh::QuadPerEdgeAA::GetIndexBuffer	(	GrMeshDrawTarget *	target,
		IndexBufferOption	indexBufferOption
	)

Definition at line 460 of file QuadPerEdgeAA.cpp.

                                                                          {
    auto resourceProvider = target->resourceProvider();
 
    switch (indexBufferOption) {
        case IndexBufferOption::kPictureFramed: return resourceProvider->refAAQuadIndexBuffer();
        case IndexBufferOption::kIndexedRects:  return resourceProvider->refNonAAQuadIndexBuffer();
        case IndexBufferOption::kTriStrips:     // fall through
        default:                                return nullptr;
    }
}

IssueDraw()

void skgpu::ganesh::QuadPerEdgeAA::IssueDraw	(	const GrCaps &	caps,
		GrOpsRenderPass *	renderPass,
		const VertexSpec &	spec,
		int	runningQuadCount,
		int	quadsInDraw,
		int	maxVerts,
		int	absVertBufferOffset
	)

Definition at line 482 of file QuadPerEdgeAA.cpp.

                                                                                             {
    if (spec.indexBufferOption() == IndexBufferOption::kTriStrips) {
        int offset = absVertBufferOffset +
                                    runningQuadCount * GrResourceProvider::NumVertsPerNonAAQuad();
        renderPass->draw(4, offset);
        return;
    }
 
    SkASSERT(spec.indexBufferOption() == IndexBufferOption::kPictureFramed ||
             spec.indexBufferOption() == IndexBufferOption::kIndexedRects);
 
    int maxNumQuads, numIndicesPerQuad, numVertsPerQuad;
 
    if (spec.indexBufferOption() == IndexBufferOption::kPictureFramed) {
        // AA uses 8 vertices and 30 indices per quad, basically nested rectangles
        maxNumQuads = GrResourceProvider::MaxNumAAQuads();
        numIndicesPerQuad = GrResourceProvider::NumIndicesPerAAQuad();
        numVertsPerQuad = GrResourceProvider::NumVertsPerAAQuad();
    } else {
        // Non-AA uses 4 vertices and 6 indices per quad
        maxNumQuads = GrResourceProvider::MaxNumNonAAQuads();
        numIndicesPerQuad = GrResourceProvider::NumIndicesPerNonAAQuad();
        numVertsPerQuad = GrResourceProvider::NumVertsPerNonAAQuad();
    }
 
    SkASSERT(runningQuadCount + quadsInDraw <= maxNumQuads);
 
    if (caps.avoidLargeIndexBufferDraws()) {
        // When we need to avoid large index buffer draws we modify the base vertex of the draw
        // which, in GL, requires rebinding all vertex attrib arrays, so a base index is generally
        // preferred.
        int offset = absVertBufferOffset + runningQuadCount * numVertsPerQuad;
 
        renderPass->drawIndexPattern(numIndicesPerQuad, quadsInDraw, maxNumQuads, numVertsPerQuad,
                                     offset);
    } else {
        int baseIndex = runningQuadCount * numIndicesPerQuad;
        int numIndicesToDraw = quadsInDraw * numIndicesPerQuad;
 
        int minVertex = runningQuadCount * numVertsPerQuad;
        int maxVertex = (runningQuadCount + quadsInDraw) * numVertsPerQuad - 1; // inclusive
 
        renderPass->drawIndexed(numIndicesToDraw, baseIndex, minVertex, maxVertex,
                                absVertBufferOffset);
    }
}

MakeProcessor()

GrGeometryProcessor * skgpu::ganesh::QuadPerEdgeAA::MakeProcessor	(	SkArenaAlloc *	arena,
		const VertexSpec &	spec
	)

Definition at line 909 of file QuadPerEdgeAA.cpp.

                                                                                {
    return QuadPerEdgeAAGeometryProcessor::Make(arena, spec);
}

MakeTexturedProcessor()

GrGeometryProcessor * skgpu::ganesh::QuadPerEdgeAA::MakeTexturedProcessor	(	SkArenaAlloc *	arena,
		const VertexSpec &	spec,
		const GrShaderCaps &	caps,
		const GrBackendFormat &	backendFormat,
		GrSamplerState	samplerState,
		const skgpu::Swizzle &	swizzle,
		sk_sp< GrColorSpaceXform >	textureColorSpaceXform,
		Saturate	saturate
	)

Definition at line 913 of file QuadPerEdgeAA.cpp.

                                                              {
    return QuadPerEdgeAAGeometryProcessor::Make(arena, spec, caps, backendFormat, samplerState,
                                                swizzle, std::move(textureColorSpaceXform),
                                                saturate);
}

MinColorType()

ColorType skgpu::ganesh::QuadPerEdgeAA::MinColorType

(

SkPMColor4f

color

)

Definition at line 316 of file QuadPerEdgeAA.cpp.

                                          {
    if (color == SK_PMColor4fWHITE) {
        return ColorType::kNone;
    } else {
        return color.fitsInBytes() ? ColorType::kByte : ColorType::kFloat;
    }
}

QuadLimit()

int skgpu::ganesh::QuadPerEdgeAA::QuadLimit

(

IndexBufferOption

option

)

Definition at line 472 of file QuadPerEdgeAA.cpp.

                                        {
    switch (option) {
        case IndexBufferOption::kPictureFramed: return GrResourceProvider::MaxNumAAQuads();
        case IndexBufferOption::kIndexedRects:  return GrResourceProvider::MaxNumNonAAQuads();
        case IndexBufferOption::kTriStrips:     return SK_MaxS32; // not limited by an indexBuffer
    }
 
    SkUNREACHABLE;
}

Variable Documentation

kColorTypeCount

const int skgpu::ganesh::QuadPerEdgeAA::kColorTypeCount = static_cast<int>(ColorType::kLast) + 1

static

Definition at line 35 of file QuadPerEdgeAA.h.

kIndexBufferOptionCount

const int skgpu::ganesh::QuadPerEdgeAA::kIndexBufferOptionCount = static_cast<int>(IndexBufferOption::kLast) + 1

static

Definition at line 43 of file QuadPerEdgeAA.h.