skgpu::ganesh::AtlasTextOp Class Reference

#include <AtlasTextOp.h>

Inheritance diagram for skgpu::ganesh::AtlasTextOp:

Classes
struct	Geometry

Public Types
enum class	MaskType : uint32_t {   kGrayscaleCoverage , kLCDCoverage , kColorBitmap , kAliasedDistanceField ,   kGrayscaleDistanceField , kLCDDistanceField , kLCDBGRDistanceField , kLast = kLCDBGRDistanceField }
Public Types inherited from GrDrawOp
enum class	ClipResult { kFail , kClippedGeometrically , kClippedInShader , kClippedOut }
Public Types inherited from GrOp
enum class	CombineResult { kMerged , kMayChain , kCannotCombine }
enum class	HasAABloat : bool { kNo = false , kYes = true }
enum class	IsHairline : bool { kNo = false , kYes = true }
using	Owner = std::unique_ptr< GrOp >

Public Member Functions
DEFINE_OP_CLASS_ID	~AtlasTextOp () override
void *	operator new (size_t s)
void	operator delete (void *b) noexcept
const char *	name () const override
void	visitProxies (const GrVisitProxyFunc &) const override
FixedFunctionFlags	fixedFunctionFlags () const override
GrProcessorSet::Analysis	finalize (const GrCaps &, const GrAppliedClip *, GrClampType) override
Public Member Functions inherited from GrDrawOp
	GrDrawOp (uint32_t classID)
virtual bool	usesMSAA () const
virtual ClipResult	clipToShape (skgpu::ganesh::SurfaceDrawContext *, SkClipOp, const SkMatrix &, const GrShape &, GrAA)
virtual bool	usesStencil () const
Public Member Functions inherited from GrOp
virtual	~GrOp ()=default
CombineResult	combineIfPossible (GrOp *that, SkArenaAlloc *alloc, const GrCaps &caps)
const SkRect &	bounds () const
void	setClippedBounds (const SkRect &clippedBounds)
bool	hasAABloat () const
bool	hasZeroArea () const
void	operator delete (void *p)
template<typename T >
const T &	cast () const
template<typename T >
T *	cast ()
uint32_t	classID () const
uint32_t	uniqueID () const
void	prePrepare (GrRecordingContext *context, const GrSurfaceProxyView &dstView, GrAppliedClip *clip, const GrDstProxyView &dstProxyView, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)
void	prepare (GrOpFlushState *state)
void	execute (GrOpFlushState *state, const SkRect &chainBounds)
void	chainConcat (GrOp::Owner)
bool	isChainHead () const
bool	isChainTail () const
GrOp *	nextInChain () const
GrOp *	prevInChain () const
GrOp::Owner	cutChain ()
void	setBounds (const SkRect &newBounds, HasAABloat aabloat, IsHairline zeroArea)
void	setTransformedBounds (const SkRect &srcBounds, const SkMatrix &m, HasAABloat aabloat, IsHairline zeroArea)
void	makeFullScreen (GrSurfaceProxy *proxy)

Static Public Member Functions
static void	ClearCache ()
Static Public Member Functions inherited from GrMeshDrawOp
static bool	CanUpgradeAAOnMerge (GrAAType aa1, GrAAType aa2)
Static Public Member Functions inherited from GrOp
template<typename Op , typename... Args>
static Owner	Make (GrRecordingContext *context, Args &&... args)
template<typename Op , typename... Args>
static Owner	MakeWithProcessorSet (GrRecordingContext *context, const SkPMColor4f &color, GrPaint &&paint, Args &&... args)
template<typename Op , typename... Args>
static Owner	MakeWithExtraMemory (GrRecordingContext *context, size_t extraSize, Args &&... args)
static uint32_t	GenOpClassID ()

Static Public Attributes
static constexpr int	kMaskTypeCount = static_cast<int>(MaskType::kLast) + 1

Private Member Functions
GrProgramInfo *	programInfo () override
void	onCreateProgramInfo (const GrCaps *, SkArenaAlloc *, const GrSurfaceProxyView &writeView, bool usesMSAASurface, GrAppliedClip &&, const GrDstProxyView &, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp) override
void	onPrePrepareDraws (GrRecordingContext *, const GrSurfaceProxyView &writeView, GrAppliedClip *, const GrDstProxyView &, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp) override
void	onPrepareDraws (GrMeshDrawTarget *) override
void	onExecute (GrOpFlushState *, const SkRect &chainBounds) override
CombineResult	onCombineIfPossible (GrOp *t, SkArenaAlloc *, const GrCaps &caps) override

Friends
class	GrOp

Additional Inherited Members
Protected Types inherited from GrDrawOp
enum class	FixedFunctionFlags : uint32_t { kNone = 0x0 , kUsesHWAA = 0x1 , kUsesStencil = 0x2 }
Protected Member Functions inherited from GrMeshDrawOp
	GrMeshDrawOp (uint32_t classID)
void	createProgramInfo (const GrCaps *caps, SkArenaAlloc *arena, const GrSurfaceProxyView &writeView, bool usesMSAASurface, GrAppliedClip &&appliedClip, const GrDstProxyView &dstProxyView, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)
void	createProgramInfo (GrMeshDrawTarget *)
Protected Member Functions inherited from GrDrawOp
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (FixedFunctionFlags)
Static Protected Member Functions inherited from GrMeshDrawOp
static bool	CombinedQuadCountWillOverflow (GrAAType aaType, bool willBeUpgradedToAA, int combinedQuadCount)

Detailed Description

Definition at line 52 of file AtlasTextOp.h.

Member Enumeration Documentation

MaskType

enum class skgpu::ganesh::AtlasTextOp::MaskType : uint32_t

strong

Enumerator
kGrayscaleCoverage
kLCDCoverage
kColorBitmap
kAliasedDistanceField
kGrayscaleDistanceField
kLCDDistanceField
kLCDBGRDistanceField
kLast

Definition at line 121 of file AtlasTextOp.h.

                        : uint32_t {
        kGrayscaleCoverage,
        kLCDCoverage,
        kColorBitmap,
#if !defined(SK_DISABLE_SDF_TEXT)
        kAliasedDistanceField,
        kGrayscaleDistanceField,
        kLCDDistanceField,
        kLCDBGRDistanceField,
 
        kLast = kLCDBGRDistanceField
#else
        kLast = kColorBitmap
#endif
    };

Constructor & Destructor Documentation

~AtlasTextOp()

DEFINE_OP_CLASS_ID skgpu::ganesh::AtlasTextOp::~AtlasTextOp ( )

inlineoverride

Definition at line 56 of file AtlasTextOp.h.

                            {
        for (const Geometry* g = fHead; g != nullptr;) {
            const Geometry* next = g->fNext;
            g->~Geometry();
            g = next;
        }
    }

Member Function Documentation

ClearCache()

void skgpu::ganesh::AtlasTextOp::ClearCache ( )

static

Definition at line 76 of file AtlasTextOp.cpp.

                             {
    ::operator delete(gCache);
    gCache = nullptr;
}

finalize()

GrProcessorSet::Analysis skgpu::ganesh::AtlasTextOp::finalize ( const GrCaps &  , const GrAppliedClip *  , GrClampType    )

overridevirtual

This is called after the GrAppliedClip has been computed and just prior to recording the op or combining it with a previously recorded op. The op should convert any proxies or resources it owns to "pending io" status so that resource allocation can be more optimal. Additionally, at this time the op must report whether a copy of the destination (or destination texture itself) needs to be provided to the GrXferProcessor when this op executes.

Implements GrDrawOp.

Definition at line 182 of file AtlasTextOp.cpp.

                                                                      {
    GrProcessorAnalysisCoverage coverage;
    GrProcessorAnalysisColor color;
    if (this->maskType() == MaskType::kColorBitmap) {
        color.setToUnknown();
    } else {
        // finalize() is called before any merging is done, so at this point there's at most one
        // Geometry with a color. Later, for non-bitmap ops, we may have mixed colors.
        color.setToConstant(fHead->fColor);
    }
 
    switch (this->maskType()) {
        case MaskType::kGrayscaleCoverage:
#if !defined(SK_DISABLE_SDF_TEXT)
        case MaskType::kAliasedDistanceField:
        case MaskType::kGrayscaleDistanceField:
#endif
            coverage = GrProcessorAnalysisCoverage::kSingleChannel;
            break;
        case MaskType::kLCDCoverage:
#if !defined(SK_DISABLE_SDF_TEXT)
        case MaskType::kLCDDistanceField:
        case MaskType::kLCDBGRDistanceField:
#endif
            coverage = GrProcessorAnalysisCoverage::kLCD;
            break;
        case MaskType::kColorBitmap:
            coverage = GrProcessorAnalysisCoverage::kNone;
            break;
    }
 
    auto analysis = fProcessors.finalize(color, coverage, clip, &GrUserStencilSettings::kUnused,
                                         caps, clampType, &fHead->fColor);
    // TODO(michaelludwig): Once processor analysis can be done external to op creation/finalization
    // the atlas op metadata can be fully const. This is okay for now since finalize() happens
    // before the op is merged, so during combineIfPossible, metadata is effectively const.
    fUsesLocalCoords = analysis.usesLocalCoords();
    return analysis;
}

fixedFunctionFlags()

GrDrawOp::FixedFunctionFlags skgpu::ganesh::AtlasTextOp::fixedFunctionFlags ( ) const

overridevirtual

Reimplemented from GrDrawOp.

Definition at line 178 of file AtlasTextOp.cpp.

                                                                 {
    return FixedFunctionFlags::kNone;
}

name()

const char * skgpu::ganesh::AtlasTextOp::name ( ) const

inlineoverridevirtual

Implements GrOp.

Definition at line 113 of file AtlasTextOp.h.

{ return "AtlasTextOp"; }

onCombineIfPossible()

GrOp::CombineResult skgpu::ganesh::AtlasTextOp::onCombineIfPossible ( GrOp *  t, SkArenaAlloc *  , const GrCaps &  caps  )

overrideprivatevirtual

Reimplemented from GrOp.

Definition at line 438 of file AtlasTextOp.cpp.

                                                                                             {
    auto that = t->cast<AtlasTextOp>();
 
    if (fDFGPFlags != that->fDFGPFlags ||
        fMaskType != that->fMaskType ||
        fUsesLocalCoords != that->fUsesLocalCoords ||
        fNeedsGlyphTransform != that->fNeedsGlyphTransform ||
        fHasPerspective != that->fHasPerspective ||
        fUseGammaCorrectDistanceTable != that->fUseGammaCorrectDistanceTable) {
        // All flags must match for an op to be combined
        return CombineResult::kCannotCombine;
    }
 
    if (fProcessors != that->fProcessors) {
        return CombineResult::kCannotCombine;
    }
 
    if (fUsesLocalCoords) {
        // If the fragment processors use local coordinates, the GPs compute them using the inverse
        // of the view matrix stored in a uniform, so all geometries must have the same matrix.
        const SkMatrix& thisFirstMatrix = fHead->fDrawMatrix;
        const SkMatrix& thatFirstMatrix = that->fHead->fDrawMatrix;
        if (!SkMatrixPriv::CheapEqual(thisFirstMatrix, thatFirstMatrix)) {
            return CombineResult::kCannotCombine;
        }
    }
 
#if !defined(SK_DISABLE_SDF_TEXT)
   if (this->usesDistanceFields()) {
        SkASSERT(that->usesDistanceFields());
        if (fLuminanceColor != that->fLuminanceColor) {
            return CombineResult::kCannotCombine;
        }
    } else
#endif
    {
        if (this->maskType() == MaskType::kColorBitmap &&
            fHead->fColor != that->fHead->fColor) {
            // This ensures all merged bitmap color text ops have a constant color
            return CombineResult::kCannotCombine;
        }
    }
 
    fNumGlyphs += that->fNumGlyphs;
 
    // After concat, that's geometry list is emptied so it will not unref the blobs when destructed
    this->addGeometry(that->fHead);
    that->fHead = nullptr;
    return CombineResult::kMerged;
}

onCreateProgramInfo()

void skgpu::ganesh::AtlasTextOp::onCreateProgramInfo ( const GrCaps *  , SkArenaAlloc *  , const GrSurfaceProxyView &  writeView, bool  usesMSAASurface, GrAppliedClip &&  , const GrDstProxyView &  , GrXferBarrierFlags  renderPassXferBarriers, GrLoadOp  colorLoadOp  )

inlineoverrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 182 of file AtlasTextOp.h.

                                                            {
        // We cannot surface the AtlasTextOp's programInfo at record time. As currently
        // implemented, the GP is modified at flush time based on the number of pages in the
        // atlas.
    }

onExecute()

void skgpu::ganesh::AtlasTextOp::onExecute ( GrOpFlushState *  flushState, const SkRect &  chainBounds  )

overrideprivatevirtual

Implements GrOp.

Definition at line 369 of file AtlasTextOp.cpp.

                                                                                 {
    auto pipeline = GrSimpleMeshDrawOpHelper::CreatePipeline(flushState,
                                                             std::move(fProcessors),
                                                             GrPipeline::InputFlags::kNone);
 
    flushState->executeDrawsAndUploadsForMeshDrawOp(this, chainBounds, pipeline,
                                                    &GrUserStencilSettings::kUnused);
}

onPrepareDraws()

void skgpu::ganesh::AtlasTextOp::onPrepareDraws ( GrMeshDrawTarget *  target )

overrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 224 of file AtlasTextOp.cpp.

                                                         {
    auto resourceProvider = target->resourceProvider();
 
    // If we need local coordinates, compute an inverse view matrix. If this is solid color, the
    // processor analysis will not require local coords and the GPs will skip local coords when
    // the matrix is identity. When the shaders require local coords, combineIfPossible requires all
    // all geometries to have same draw matrix.
    SkMatrix localMatrix = SkMatrix::I();
    if (fUsesLocalCoords && !fHead->fDrawMatrix.invert(&localMatrix)) {
        return;
    }
 
    GrAtlasManager* atlasManager = target->atlasManager();
 
    MaskFormat maskFormat = this->maskFormat();
 
    unsigned int numActiveViews;
    const GrSurfaceProxyView* views = atlasManager->getViews(maskFormat, &numActiveViews);
    if (!views) {
        SkDebugf("Could not allocate backing texture for atlas\n");
        return;
    }
    SkASSERT(views[0].proxy());
 
    static constexpr int kMaxTextures = GrBitmapTextGeoProc::kMaxTextures;
#if !defined(SK_DISABLE_SDF_TEXT)
    static_assert(GrDistanceFieldA8TextGeoProc::kMaxTextures == kMaxTextures);
    static_assert(GrDistanceFieldLCDTextGeoProc::kMaxTextures == kMaxTextures);
#endif
 
    auto primProcProxies = target->allocPrimProcProxyPtrs(kMaxTextures);
    for (unsigned i = 0; i < numActiveViews; ++i) {
        primProcProxies[i] = views[i].proxy();
        // This op does not know its atlas proxies when it is added to a OpsTasks, so the proxies
        // don't get added during the visitProxies call. Thus we add them here.
        target->sampledProxyArray()->push_back(views[i].proxy());
    }
 
    FlushInfo flushInfo;
    flushInfo.fPrimProcProxies = primProcProxies;
    flushInfo.fIndexBuffer = resourceProvider->refNonAAQuadIndexBuffer();
 
#if !defined(SK_DISABLE_SDF_TEXT)
    if (this->usesDistanceFields()) {
        flushInfo.fGeometryProcessor = this->setupDfProcessor(target->allocator(),
                                                              *target->caps().shaderCaps(),
                                                              localMatrix, views, numActiveViews);
    } else
#endif
    {
        auto filter = fNeedsGlyphTransform ? GrSamplerState::Filter::kLinear
                                           : GrSamplerState::Filter::kNearest;
        // Bitmap text uses a single color, combineIfPossible ensures all geometries have the same
        // color, so we can use the first's without worry.
        flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
                target->allocator(), *target->caps().shaderCaps(), fHead->fColor,
                /*wideColor=*/false, fColorSpaceXform, views, numActiveViews, filter,
                maskFormat, localMatrix, fHasPerspective);
    }
 
    const int vertexStride = (int)flushInfo.fGeometryProcessor->vertexStride();
 
    // Ensure we don't request an insanely large contiguous vertex allocation.
    static const int kMaxVertexBytes = GrBufferAllocPool::kDefaultBufferSize;
    const int quadSize = vertexStride * kVerticesPerGlyph;
    const int maxQuadsPerBuffer = kMaxVertexBytes / quadSize;
 
    int allGlyphsCursor = 0;
    const int allGlyphsEnd = fNumGlyphs;
    int quadCursor;
    int quadEnd;
    char* vertices;
 
    auto resetVertexBuffer = [&] {
        quadCursor = 0;
        quadEnd = std::min(maxQuadsPerBuffer, allGlyphsEnd - allGlyphsCursor);
 
        vertices = (char*)target->makeVertexSpace(
                vertexStride,
                kVerticesPerGlyph * quadEnd,
                &flushInfo.fVertexBuffer,
                &flushInfo.fVertexOffset);
 
        if (!vertices || !flushInfo.fVertexBuffer) {
            SkDebugf("Could not allocate vertices\n");
            return false;
        }
        return true;
    };
 
    if (!resetVertexBuffer()) {
        return;
    }
 
    for (const Geometry* geo = fHead; geo != nullptr; geo = geo->fNext) {
        const sktext::gpu::AtlasSubRun& subRun = geo->fSubRun;
        SkASSERTF((int) subRun.vertexStride(geo->fDrawMatrix) == vertexStride,
                  "subRun stride: %d vertex buffer stride: %d\n",
                  (int)subRun.vertexStride(geo->fDrawMatrix), vertexStride);
 
        const int subRunEnd = subRun.glyphCount();
        auto regenerateDelegate = [&](sktext::gpu::GlyphVector* glyphs,
                                      int begin,
                                      int end,
                                      skgpu::MaskFormat maskFormat,
                                      int padding) {
            return glyphs->regenerateAtlasForGanesh(begin, end, maskFormat, padding, target);
        };
        for (int subRunCursor = 0; subRunCursor < subRunEnd;) {
            // Regenerate the atlas for the remainder of the glyphs in the run, or the remainder
            // of the glyphs to fill the vertex buffer.
            int regenEnd = subRunCursor + std::min(subRunEnd - subRunCursor, quadEnd - quadCursor);
            auto[ok, glyphsRegenerated] = subRun.regenerateAtlas(subRunCursor, regenEnd,
                                                                 regenerateDelegate);
            // There was a problem allocating the glyph in the atlas. Bail.
            if (!ok) {
                return;
            }
 
            geo->fillVertexData(vertices + quadCursor * quadSize, subRunCursor, glyphsRegenerated);
 
            subRunCursor += glyphsRegenerated;
            quadCursor += glyphsRegenerated;
            allGlyphsCursor += glyphsRegenerated;
            flushInfo.fGlyphsToFlush += glyphsRegenerated;
 
            if (quadCursor == quadEnd || subRunCursor < subRunEnd) {
                // Flush if not all the glyphs are drawn because either the quad buffer is full or
                // the atlas is out of space.
                if (subRunCursor < subRunEnd) {
                    ATRACE_ANDROID_FRAMEWORK_ALWAYS("Atlas full");
                }
                this->createDrawForGeneratedGlyphs(target, &flushInfo);
                if (quadCursor == quadEnd && allGlyphsCursor < allGlyphsEnd) {
                    // If the vertex buffer is full and there are still glyphs to draw then
                    // get a new buffer.
                    if(!resetVertexBuffer()) {
                        return;
                    }
                }
            }
        }
    }
}

onPrePrepareDraws()

void skgpu::ganesh::AtlasTextOp::onPrePrepareDraws ( GrRecordingContext *  , const GrSurfaceProxyView &  writeView, GrAppliedClip *  , const GrDstProxyView &  , GrXferBarrierFlags  renderPassXferBarriers, GrLoadOp  colorLoadOp  )

inlineoverrideprivatevirtual

Reimplemented from GrMeshDrawOp.

Definition at line 195 of file AtlasTextOp.h.

                                                          {
        // TODO [PI]: implement
    }

operator delete()

void skgpu::ganesh::AtlasTextOp::operator delete ( void *  b )

noexcept

Definition at line 68 of file AtlasTextOp.cpp.

                                                      {
    if (gCache == nullptr) {
        gCache = bytes;
        return;
    }
    ::operator delete(bytes);
}

operator new()

void * skgpu::ganesh::AtlasTextOp::operator new

(

size_t

s

)

Definition at line 60 of file AtlasTextOp.cpp.

                                        {
    if (gCache != nullptr) {
        return std::exchange(gCache, nullptr);
    }
 
    return ::operator new(s);
}

programInfo()

GrProgramInfo * skgpu::ganesh::AtlasTextOp::programInfo ( )

inlineoverrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 169 of file AtlasTextOp.h.

                                          {
        // TODO [PI]: implement
        return nullptr;
    }

visitProxies()

void skgpu::ganesh::AtlasTextOp::visitProxies ( const GrVisitProxyFunc &  func ) const

overridevirtual

Reimplemented from GrOp.

Definition at line 157 of file AtlasTextOp.cpp.

                                                                 {
    fProcessors.visitProxies(func);
}

Friends And Related Symbol Documentation

GrOp

friend class GrOp

friend

Definition at line 139 of file AtlasTextOp.h.

Member Data Documentation

kMaskTypeCount

constexpr int skgpu::ganesh::AtlasTextOp::kMaskTypeCount = static_cast<int>(MaskType::kLast) + 1

inlinestaticconstexpr

Definition at line 136 of file AtlasTextOp.h.

---

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

• third_party/skia/src/gpu/ganesh/ops/AtlasTextOp.h
• third_party/skia/src/gpu/ganesh/ops/AtlasTextOp.cpp