TextureSetRenderer Class Reference

Inheritance diagram for TextureSetRenderer:

Public Member Functions
int	drawTiles (SkCanvas *canvas) override
int	drawTile (SkCanvas *canvas, const SkRect &rect, const SkPoint clip[4], const bool edgeAA[4], int tileID, int quadID) override
void	drawBanner (SkCanvas *canvas) override
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< ClipTileRenderer >	MakeUnbatched (sk_sp< SkImage > image)
static sk_sp< ClipTileRenderer >	MakeBatched (sk_sp< SkImage > image, int transformCount)
static sk_sp< ClipTileRenderer >	MakeShader (const char *name, sk_sp< SkImage > image, sk_sp< SkShader > shader, bool local)
static sk_sp< ClipTileRenderer >	MakeColorFilter (const char *name, sk_sp< SkImage > image, sk_sp< SkColorFilter > filter)
static sk_sp< ClipTileRenderer >	MakeImageFilter (const char *name, sk_sp< SkImage > image, sk_sp< SkImageFilter > filter)
static sk_sp< ClipTileRenderer >	MakeMaskFilter (const char *name, sk_sp< SkImage > image, sk_sp< SkMaskFilter > filter)
static sk_sp< ClipTileRenderer >	MakeAlpha (sk_sp< SkImage > image, SkScalar alpha)
static sk_sp< ClipTileRenderer >	Make (const char *topBanner, const char *bottomBanner, sk_sp< SkImage > image, sk_sp< SkShader > shader, sk_sp< SkColorFilter > colorFilter, sk_sp< SkImageFilter > imageFilter, sk_sp< SkMaskFilter > maskFilter, SkScalar paintAlpha, bool resetAfterEachQuad, int transformCount)

Additional Inherited Members
Protected Member Functions inherited from ClipTileRenderer
SkCanvas::QuadAAFlags	maskToFlags (const bool edgeAA[4]) const
int	clipTile (SkCanvas *canvas, int tileID, const SkRect &baseRect, const SkPoint quad[4], const bool edgeAA[4], const SkPoint lines[], int lineCount, int *quadCount)

Detailed Description

Definition at line 648 of file compositor_quads.cpp.

Member Function Documentation

drawBanner()

void TextureSetRenderer::drawBanner ( SkCanvas *  canvas )

inlineoverridevirtual

Implements ClipTileRenderer.

Definition at line 764 of file compositor_quads.cpp.

                                               {
        if (fTopBanner.size() > 0) {
            draw_text(canvas, fTopBanner.c_str());
        }
        canvas->translate(0.f, 15.f);
        if (fBottomBanner.size() > 0) {
            draw_text(canvas, fBottomBanner.c_str());
        }
    }

drawTile()

int TextureSetRenderer::drawTile ( SkCanvas *  canvas, const SkRect &  rect, const SkPoint  clip[4], const bool  edgeAA[4], int  tileID, int  quadID  )

inlineoverridevirtual

Implements ClipTileRenderer.

Definition at line 709 of file compositor_quads.cpp.

                                                   {
        // Now don't actually draw the tile, accumulate it in the growing entry set
        bool hasClip = false;
        if (clip) {
            // Record the four points into fDstClips
            fDstClips.push_back_n(4, clip);
            hasClip = true;
        }
 
        int matrixIdx = -1;
        if (!fResetEachQuad && fTransformBatchCount > 0) {
            // Handle transform batching. This works by capturing the CTM of the first tile draw,
            // and then calculate the difference between that and future CTMs for later tiles.
            if (fPreViewMatrices.size() == 0) {
                fBaseCTM = canvas->getTotalMatrix();
                fPreViewMatrices.push_back(SkMatrix::I());
                matrixIdx = 0;
            } else {
                // Calculate matrix s.t. getTotalMatrix() = fBaseCTM * M
                SkMatrix invBase;
                if (!fBaseCTM.invert(&invBase)) {
                    SkDebugf("Cannot invert CTM, transform batching will not be correct.\n");
                } else {
                    SkMatrix preView = SkMatrix::Concat(invBase, canvas->getTotalMatrix());
                    if (preView != fPreViewMatrices[fPreViewMatrices.size() - 1]) {
                        // Add the new matrix
                        fPreViewMatrices.push_back(preView);
                    } // else re-use the last matrix
                    matrixIdx = fPreViewMatrices.size() - 1;
                }
            }
        }
 
        // This acts like the whole image is rendered over the entire tile grid, so derive local
        // coordinates from 'rect', based on the grid to image transform.
        SkMatrix gridToImage = SkMatrix::RectToRect(SkRect::MakeWH(kColCount * kTileWidth,
                                                                   kRowCount * kTileHeight),
                                                    SkRect::MakeWH(fImage->width(),
                                                                   fImage->height()));
        SkRect localRect = gridToImage.mapRect(rect);
 
        // drawTextureSet automatically derives appropriate local quad from localRect if clipPtr
        // is not null.
        fSetEntries.push_back(
                {fImage, localRect, rect, matrixIdx, 1.f, this->maskToFlags(edgeAA), hasClip});
 
        if (fResetEachQuad) {
            // Only ever draw one entry at a time
            return this->drawAndReset(canvas);
        } else {
            return 0;
        }
    }

drawTiles()

int TextureSetRenderer::drawTiles ( SkCanvas *  canvas )

inlineoverridevirtual

Reimplemented from ClipTileRenderer.

Definition at line 702 of file compositor_quads.cpp.

                                             {
        int draws = this->INHERITED::drawTiles(canvas);
        // Push the last tile set
        draws += this->drawAndReset(canvas);
        return draws;
    }

Make()

static sk_sp< ClipTileRenderer > TextureSetRenderer::Make ( const char *  topBanner, const char *  bottomBanner, sk_sp< SkImage >  image, sk_sp< SkShader >  shader, sk_sp< SkColorFilter >  colorFilter, sk_sp< SkImageFilter >  imageFilter, sk_sp< SkMaskFilter >  maskFilter, SkScalar  paintAlpha, bool  resetAfterEachQuad, int  transformCount  )

inlinestatic

Definition at line 691 of file compositor_quads.cpp.

                                                                                     {
        return sk_sp<ClipTileRenderer>(new TextureSetRenderer(topBanner, bottomBanner,
                std::move(image), std::move(shader), std::move(colorFilter), std::move(imageFilter),
                std::move(maskFilter), paintAlpha, resetAfterEachQuad, transformCount));
    }

MakeAlpha()

static sk_sp< ClipTileRenderer > TextureSetRenderer::MakeAlpha ( sk_sp< SkImage >  image, SkScalar  alpha  )

inlinestatic

Definition at line 686 of file compositor_quads.cpp.

                                                                                   {
        return Make("Alpha", SkStringPrintf("a = %.2f", alpha).c_str(), std::move(image), nullptr,
                    nullptr, nullptr, nullptr, alpha, false, 0);
    }

MakeBatched()

static sk_sp< ClipTileRenderer > TextureSetRenderer::MakeBatched ( sk_sp< SkImage >  image, int  transformCount  )

inlinestatic

Definition at line 656 of file compositor_quads.cpp.

                                                                                         {
        const char* subtitle = transformCount == 0 ? "" : "w/ xforms";
        return Make("Texture Set", subtitle, std::move(image), nullptr, nullptr, nullptr, nullptr,
                    1.f, false, transformCount);
    }

MakeColorFilter()

static sk_sp< ClipTileRenderer > TextureSetRenderer::MakeColorFilter ( const char *  name, sk_sp< SkImage >  image, sk_sp< SkColorFilter >  filter  )

inlinestatic

Definition at line 668 of file compositor_quads.cpp.

                                                                                {
        return Make("Color Filter", name, std::move(image), nullptr, std::move(filter), nullptr,
                    nullptr, 1.f, false, 0);
    }

MakeImageFilter()

static sk_sp< ClipTileRenderer > TextureSetRenderer::MakeImageFilter ( const char *  name, sk_sp< SkImage >  image, sk_sp< SkImageFilter >  filter  )

inlinestatic

Definition at line 674 of file compositor_quads.cpp.

                                                                                {
        return Make("Image Filter", name, std::move(image), nullptr, nullptr, std::move(filter),
                    nullptr, 1.f, false, 0);
    }

MakeMaskFilter()

static sk_sp< ClipTileRenderer > TextureSetRenderer::MakeMaskFilter ( const char *  name, sk_sp< SkImage >  image, sk_sp< SkMaskFilter >  filter  )

inlinestatic

Definition at line 680 of file compositor_quads.cpp.

                                                                              {
        return Make("Mask Filter", name, std::move(image), nullptr, nullptr, nullptr,
                    std::move(filter), 1.f, false, 0);
    }

MakeShader()

static sk_sp< ClipTileRenderer > TextureSetRenderer::MakeShader ( const char *  name, sk_sp< SkImage >  image, sk_sp< SkShader >  shader, bool  local  )

inlinestatic

Definition at line 662 of file compositor_quads.cpp.

                                                                                  {
        return Make("Shader", name, std::move(image), std::move(shader),
                    nullptr, nullptr, nullptr, 1.f, local, 0);
    }

MakeUnbatched()

static sk_sp< ClipTileRenderer > TextureSetRenderer::MakeUnbatched ( sk_sp< SkImage >  image )

inlinestatic

Definition at line 651 of file compositor_quads.cpp.

                                                                       {
        return Make("Texture", "", std::move(image), nullptr, nullptr, nullptr, nullptr,
                    1.f, true, 0);
    }

---

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

• third_party/skia/gm/compositor_quads.cpp