skgpu::graphite::GridBoundsManager Class Reference

#include <BoundsManager.h>

Inheritance diagram for skgpu::graphite::GridBoundsManager:

Public Member Functions
	~GridBoundsManager () override
CompressedPaintersOrder	getMostRecentDraw (const Rect &bounds) const override
void	recordDraw (const Rect &bounds, CompressedPaintersOrder order) override
void	reset () override
Public Member Functions inherited from skgpu::graphite::BoundsManager
virtual	~BoundsManager ()

Static Public Member Functions
static std::unique_ptr< GridBoundsManager >	Make (const SkISize &deviceSize, const SkISize &gridSize)
static std::unique_ptr< GridBoundsManager >	Make (const SkISize &deviceSize, int gridSize)
static std::unique_ptr< GridBoundsManager >	MakeRes (SkISize deviceSize, int gridCellSize, int maxGridSize=0)

Detailed Description

Definition at line 121 of file BoundsManager.h.

Constructor & Destructor Documentation

~GridBoundsManager()

skgpu::graphite::GridBoundsManager::~GridBoundsManager ( )

inlineoverride

Definition at line 162 of file BoundsManager.h.

{}

Member Function Documentation

getMostRecentDraw()

CompressedPaintersOrder skgpu::graphite::GridBoundsManager::getMostRecentDraw ( const Rect &  bounds ) const

inlineoverridevirtual

Implements skgpu::graphite::BoundsManager.

Definition at line 165 of file BoundsManager.h.

                                                                                 {
        SkASSERT(!bounds.isEmptyNegativeOrNaN());
 
        auto ltrb = this->getGridCoords(bounds);
        const CompressedPaintersOrder* p = fNodes.data() + ltrb[1] * fGridWidth + ltrb[0];
        int h = ltrb[3] - ltrb[1];
        int w = ltrb[2] - ltrb[0];
 
        CompressedPaintersOrder max = CompressedPaintersOrder::First();
        for (int y = 0; y <= h; ++y ) {
            for (int x = 0; x <= w; ++x) {
                CompressedPaintersOrder v = *(p + x);
                if (v > max) {
                    max = v;
                }
            }
            p = p + fGridWidth;
        }
 
        return max;
    }

Make() [1/2]

static std::unique_ptr< GridBoundsManager > skgpu::graphite::GridBoundsManager::Make ( const SkISize &  deviceSize, const SkISize &  gridSize  )

inlinestatic

Definition at line 125 of file BoundsManager.h.

                                                                            {
        SkASSERT(deviceSize.width() > 0 && deviceSize.height() > 0);
        SkASSERT(gridSize.width() >= 1 && gridSize.height() >= 1);
 
        return std::unique_ptr<GridBoundsManager>(new GridBoundsManager(deviceSize, gridSize));
    }

Make() [2/2]

static std::unique_ptr< GridBoundsManager > skgpu::graphite::GridBoundsManager::Make ( const SkISize &  deviceSize, int  gridSize  )

inlinestatic

Definition at line 133 of file BoundsManager.h.

                                                                                          {
        return Make(deviceSize, {gridSize, gridSize});
    }

MakeRes()

static std::unique_ptr< GridBoundsManager > skgpu::graphite::GridBoundsManager::MakeRes ( SkISize  deviceSize, int  gridCellSize, int  maxGridSize = 0  )

inlinestatic

Definition at line 137 of file BoundsManager.h.

                                                                         {
        SkASSERT(deviceSize.width() > 0 && deviceSize.height() > 0);
        SkASSERT(gridCellSize >= 1);
 
        int gridWidth = SkScalarCeilToInt(deviceSize.width() / (float) gridCellSize);
        if (maxGridSize > 0 && gridWidth > maxGridSize) {
            // We'd have too many sizes so clamp the grid resolution, leave the device size alone
            // since the grid cell size can't be preserved anyways.
            gridWidth = maxGridSize;
        } else {
             // Pad out the device size to keep cell size the same
            deviceSize.fWidth = gridWidth * gridCellSize;
        }
 
        int gridHeight = SkScalarCeilToInt(deviceSize.height() / (float) gridCellSize);
        if (maxGridSize > 0 && gridHeight > maxGridSize) {
            gridHeight = maxGridSize;
        } else {
            deviceSize.fHeight = gridHeight * gridCellSize;
        }
        return Make(deviceSize, {gridWidth, gridHeight});
    }

recordDraw()

void skgpu::graphite::GridBoundsManager::recordDraw ( const Rect &  bounds, CompressedPaintersOrder  order  )

inlineoverridevirtual

Implements skgpu::graphite::BoundsManager.

Definition at line 187 of file BoundsManager.h.

                                                                                {
        SkASSERT(!bounds.isEmptyNegativeOrNaN());
 
        auto ltrb = this->getGridCoords(bounds);
        CompressedPaintersOrder* p = fNodes.data() + ltrb[1] * fGridWidth + ltrb[0];
        int h = ltrb[3] - ltrb[1];
        int w = ltrb[2] - ltrb[0];
 
        for (int y = 0; y <= h; ++y) {
            for (int x = 0; x <= w; ++x) {
                CompressedPaintersOrder v = *(p + x);
                if (order > v) {
                    *(p + x) = order;
                }
            }
            p = p + fGridWidth;
        }
    }

reset()

void skgpu::graphite::GridBoundsManager::reset ( )

inlineoverridevirtual

Implements skgpu::graphite::BoundsManager.

Definition at line 206 of file BoundsManager.h.

                          {
        memset(fNodes.data(), 0, sizeof(CompressedPaintersOrder) * fGridWidth * fGridHeight);
    }

---

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

• third_party/skia/src/gpu/graphite/geom/BoundsManager.h