SkDrawTiler Class Reference

Public Member Functions
	SkDrawTiler (SkBitmapDevice *dev, const SkRect *bounds)
bool	needsTiling () const
const SkDraw *	next ()

Static Public Member Functions
static bool	NeedsTiling (SkBitmapDevice *dev)

Detailed Description

Definition at line 60 of file SkBitmapDevice.cpp.

Constructor & Destructor Documentation

SkDrawTiler()

SkDrawTiler::SkDrawTiler ( SkBitmapDevice *  dev, const SkRect *  bounds  )

inline

Definition at line 85 of file SkBitmapDevice.cpp.

                                                           : fDevice(dev) {
        fDone = false;
 
        // we need fDst to be set, and if we're actually drawing, to dirty the genID
        if (!dev->accessPixels(&fRootPixmap)) {
            // NoDrawDevice uses us (why?) so we have to catch this case w/ no pixels
            fRootPixmap.reset(dev->imageInfo(), nullptr, 0);
        }
 
        // do a quick check, so we don't even have to process "bounds" if there is no need
        const SkIRect clipR = dev->fRCStack.rc().getBounds();
        fNeedsTiling = clipR.right() > kMaxDim || clipR.bottom() > kMaxDim;
        if (fNeedsTiling) {
            if (bounds) {
                // Make sure we round first, and then intersect. We can't rely on promoting the
                // clipR to floats (and then intersecting with devBounds) since promoting
                // int --> float can make the float larger than the int.
                // rounding(out) first runs the risk of clamping if the float is larger an intmax
                // but our roundOut() is saturating, which is fine for this use case
                //
                // e.g. the older version of this code did this:
                //    devBounds = mapRect(bounds);
                //    if (devBounds.intersect(SkRect::Make(clipR))) {
                //        fSrcBounds = devBounds.roundOut();
                // The problem being that the promotion of clipR to SkRect was unreliable
                //
                fSrcBounds = dev->localToDevice().mapRect(*bounds).roundOut();
                if (fSrcBounds.intersect(clipR)) {
                    // Check again, now that we have computed srcbounds.
                    fNeedsTiling = fSrcBounds.right() > kMaxDim || fSrcBounds.bottom() > kMaxDim;
                } else {
                    fNeedsTiling = false;
                    fDone = true;
                }
            } else {
                fSrcBounds = clipR;
            }
        }
 
        if (fNeedsTiling) {
            // fDraw.fDst and fCTM are reset each time in setupTileDraw()
            fDraw.fRC = &fTileRC;
            // we'll step/increase it before using it
            fOrigin.set(fSrcBounds.fLeft - kMaxDim, fSrcBounds.fTop);
        } else {
            // don't reference fSrcBounds, as it may not have been set
            fDraw.fDst = fRootPixmap;
            fDraw.fCTM = &dev->localToDevice();
            fDraw.fRC = &dev->fRCStack.rc();
            fOrigin.set(0, 0);
        }
 
        fDraw.fProps = &fDevice->surfaceProps();
    }

Member Function Documentation

needsTiling()

bool SkDrawTiler::needsTiling ( ) const

inline

Definition at line 140 of file SkBitmapDevice.cpp.

{ return fNeedsTiling; }

NeedsTiling()

static bool SkDrawTiler::NeedsTiling ( SkBitmapDevice *  dev )

inlinestatic

Definition at line 81 of file SkBitmapDevice.cpp.

                                                 {
        return dev->width() > kMaxDim || dev->height() > kMaxDim;
    }

next()

const SkDraw * SkDrawTiler::next ( )

inline

Definition at line 142 of file SkBitmapDevice.cpp.

                         {
        if (fDone) {
            return nullptr;
        }
        if (fNeedsTiling) {
            do {
                this->stepAndSetupTileDraw();  // might set the clip to empty and fDone to true
            } while (!fDone && fTileRC.isEmpty());
            // if we exit the loop and we're still empty, we're (past) done
            if (fTileRC.isEmpty()) {
                SkASSERT(fDone);
                return nullptr;
            }
            SkASSERT(!fTileRC.isEmpty());
        } else {
            fDone = true;   // only draw untiled once
        }
        return &fDraw;
    }

---

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

• third_party/skia/src/core/SkBitmapDevice.cpp