QGLMaskTextureCache Class Reference

Classes
struct	CacheInfo
struct	CacheLocation
struct	QuadTreeNode

Public Types
enum	{ block_size = 64 }
typedef QMultiHash< quint64, CacheInfo >	QGLTextureCacheHash

Public Functions
void	clearCache ()
CacheLocation	getMask (QGLMaskGenerator &maskGenerator, QOpenGLPaintEnginePrivate *engine)
void	maintainCache ()
void	setDrawableSize (const QSize &drawableSize)
void	setOffscreenSize (const QSize &offscreenSize)

Private Functions
void	createMask (quint64 key, CacheInfo &info, QGLMaskGenerator &maskGenerator)
quint64	hash (const QPainterPath &p, const QTransform &m, qreal w)
void	quadtreeAllocate (quint64 key, const QSize &size, QRect *rect, int *channel)
int	quadtreeBlocksize (int node)
void	quadtreeClear (int channel, const QRect &rect, int node=0)
bool	quadtreeFindAvailableLocation (const QSize &size, QRect *rect, int *channel)
void	quadtreeFindExistingLocation (const QSize &size, QRect *rect, int *channel)
void	quadtreeInsert (int channel, quint64 key, const QRect &rect, int node=0)
QPoint	quadtreeLocation (int node)
void	quadtreeUpdate (int channel, int node, int current_block_size)

Properties
QGLTextureCacheHash	cache
QSize	drawableSize
QOpenGLPaintEnginePrivate *	engine
QVector< QuadTreeNode >	occupied_quadtree [4]
QSize	offscreenSize

Detailed Description

Definition at line 163 of file qpaintengine_opengl.cpp.

Typedefs

QGLTextureCacheHash

typedef QMultiHash<quint64, CacheInfo> QGLMaskTextureCache::QGLTextureCacheHash

Definition at line 198 of file qpaintengine_opengl.cpp.

Enumerations

anonymous enum

anonymous enum

Enumerator
block_size

Definition at line 200 of file qpaintengine_opengl.cpp.

{block_size = 64};

Functions

clearCache()

void QGLMaskTextureCache::clearCache

(

)

Definition at line 2643 of file qpaintengine_opengl.cpp.

{
    cache.clear();

    int quad_tree_size = 1;

    for (int i = block_size; i < offscreenSize.width(); i *= 2)
        quad_tree_size += quad_tree_size * 4;

    for (int i = 0; i < 4; ++i) {
        occupied_quadtree[i].resize(quad_tree_size);

        occupied_quadtree[i][0].key = 0;
        occupied_quadtree[i][0].largest_available_block = offscreenSize.width();
        occupied_quadtree[i][0].largest_used_block = 0;

        DEBUG_ONCE qDebug() << "QGLMaskTextureCache:: created quad tree of size" << quad_tree_size;
    }
}

createMask()

void QGLMaskTextureCache::createMask ( quint64  key, CacheInfo &  info, QGLMaskGenerator &  maskGenerator  )

private

Definition at line 2763 of file qpaintengine_opengl.cpp.

{
    info.loc.screen_rect = maskGenerator.screenRect();

    if (info.loc.screen_rect.isEmpty()) {
        info.loc.channel = 0;
        info.loc.rect = QRect();
        return;
    }

    quadtreeAllocate(key, info.loc.screen_rect.size(), &info.loc.rect, &info.loc.channel);

    int ch = info.loc.channel;
    glColorMask(ch == 0, ch == 1, ch == 2, ch == 3);

    maskGenerator.drawMask(info.loc.rect);

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}

getMask()

QGLMaskTextureCache::CacheLocation QGLMaskTextureCache::getMask	(	QGLMaskGenerator &	maskGenerator,
		QOpenGLPaintEnginePrivate *	engine
	)

Definition at line 2688 of file qpaintengine_opengl.cpp.

{
#ifndef DISABLE_MASK_CACHE
    engine = e;

    quint64 key = hash(maskGenerator.path(), maskGenerator.matrix(), maskGenerator.strokeWidth());

    if (key == 0)
        key = 1;

    CacheInfo info(maskGenerator.path(), maskGenerator.matrix(), maskGenerator.strokeWidth());

    QGLTextureCacheHash::iterator it = cache.find(key);

    while (it != cache.end() && it.key() == key) {
        CacheInfo &cache_info = it.value();
        if (info.stroke_width == cache_info.stroke_width && info.matrix == cache_info.matrix && info.path == cache_info.path) {
            DEBUG_ONCE_STR("QGLMaskTextureCache::getMask(): Using cached mask");

            cache_info.age = 0;
            return cache_info.loc;
        }
        ++it;
    }

    // mask was not found, create new mask

    DEBUG_ONCE_STR("QGLMaskTextureCache::getMask(): Creating new mask...");

    createMask(key, info, maskGenerator);

    cache.insert(key, info);

    return info.loc;
#else
    CacheInfo info(maskGenerator.path(), maskGenerator.matrix());
    createMask(0, info, maskGenerator);
    return info.loc;
#endif
}

hash()

quint64 QGLMaskTextureCache::hash ( const QPainterPath &  p, const QTransform &  m, qreal  w  )

private

Definition at line 2733 of file qpaintengine_opengl.cpp.

{
    Q_ASSERT(sizeof(quint64) == 8);

    quint64 h = 0;

    for (int i = 0; i < p.elementCount(); ++i) {
        h += FloatToQuint64(p.elementAt(i).x) << 32;
        h += FloatToQuint64(p.elementAt(i).y);
        h += p.elementAt(i).type;
    }

    h += FloatToQuint64(m.m11());
#ifndef Q_OS_WINCE    //  ###
    //Compiler crashes for arm on WinCE
    h += FloatToQuint64(m.m12()) << 4;
    h += FloatToQuint64(m.m13()) << 8;
    h += FloatToQuint64(m.m21()) << 12;
    h += FloatToQuint64(m.m22()) << 16;
    h += FloatToQuint64(m.m23()) << 20;
    h += FloatToQuint64(m.m31()) << 24;
    h += FloatToQuint64(m.m32()) << 28;
#endif
    h += FloatToQuint64(m.m33()) << 32;

    h += FloatToQuint64(w);

    return h;
}

maintainCache()

void QGLMaskTextureCache::maintainCache

(

)

Definition at line 2668 of file qpaintengine_opengl.cpp.

{
    QGLTextureCacheHash::iterator it = cache.begin();
    QGLTextureCacheHash::iterator end = cache.end();

    while (it != end) {
        CacheInfo &cache_info = it.value();
        ++cache_info.age;

        if (cache_info.age > 1) {
            quadtreeInsert(cache_info.loc.channel, 0, cache_info.loc.rect);
            it = cache.erase(it);
        } else {
            ++it;
        }
    }
}

quadtreeAllocate()

void QGLMaskTextureCache::quadtreeAllocate ( quint64  key, const QSize &  size, QRect *  rect, int *  channel  )

private

Definition at line 3017 of file qpaintengine_opengl.cpp.

{
#ifndef DISABLE_MASK_CACHE
    if (!quadtreeFindAvailableLocation(size, rect, channel)) {
        quadtreeFindExistingLocation(size, rect, channel);
        quadtreeClear(*channel, *rect);
    }

    quadtreeInsert(*channel, key, *rect);
#else
    *channel = 0;
    *rect = QRect(QPoint(), size);
#endif
}

quadtreeBlocksize()

int QGLMaskTextureCache::quadtreeBlocksize ( int  node )

private

Definition at line 2783 of file qpaintengine_opengl.cpp.

{
    DEBUG_ONCE qDebug() << "Offscreen size:" << offscreenSize.width();

    int blocksize = offscreenSize.width();

    while (node) {
        node = (node - 1) / 4;
        blocksize /= 2;
    }

    return blocksize;
}

quadtreeClear()

void QGLMaskTextureCache::quadtreeClear ( int  channel, const QRect &  rect, int  node = 0  )

private

Definition at line 2895 of file qpaintengine_opengl.cpp.

{
    const quint64 &key = occupied_quadtree[channel][node].key;

    int current_block_size = quadtreeBlocksize(node);
    QPoint location = quadtreeLocation(node);

    QRect relative = rect.translated(-location);

    if (relative.left() >= current_block_size || relative.top() >= current_block_size
        || relative.right() < 0 || relative.bottom() < 0)
        return;

    if (key != 0) {
        QGLTextureCacheHash::iterator it = cache.find(key);

        Q_ASSERT(it != cache.end());

        while (it != cache.end() && it.key() == key) {
            const CacheInfo &cache_info = it.value();

            if (cache_info.loc.channel == channel
                && cache_info.loc.rect.left() <= location.x()
                && cache_info.loc.rect.top() <= location.y()
                && cache_info.loc.rect.right() >= location.x()
                && cache_info.loc.rect.bottom() >= location.y())
            {
                quadtreeInsert(channel, 0, cache_info.loc.rect);
                engine->cacheItemErased(channel, cache_info.loc.rect);
                cache.erase(it);
                goto found;
            } else {
                ++it;
            }
        }

        // if we don't find the key there's an error in the quadtree
        Q_ASSERT(false);
found:
        Q_ASSERT(occupied_quadtree[channel][node].key == 0);
    } else if (occupied_quadtree[channel][node].largest_available_block < current_block_size) {
        Q_ASSERT(current_block_size >= block_size);

        node = node * 4 + 1;

        for (int sibling = 0; sibling < 4; ++sibling)
            quadtreeClear(channel, rect, node + sibling);
    }
}

quadtreeFindAvailableLocation()

bool QGLMaskTextureCache::quadtreeFindAvailableLocation ( const QSize &  size, QRect *  rect, int *  channel  )

private

Definition at line 2945 of file qpaintengine_opengl.cpp.

{
    int needed_block_size = qMax(1, qMax(size.width(), size.height()));

    for (int i = 0; i < 4; ++i) {
        int current_block_size = offscreenSize.width();

        if (occupied_quadtree[i][0].largest_available_block >= needed_block_size) {
            int node = 0;

            while (current_block_size != occupied_quadtree[i][node].largest_available_block) {
                Q_ASSERT(current_block_size > block_size);
                Q_ASSERT(current_block_size > occupied_quadtree[i][node].largest_available_block);

                node = node * 4 + 1;
                current_block_size /= 2;

                int sibling = 0;

                while (occupied_quadtree[i][node + sibling].largest_available_block < needed_block_size)
                    ++sibling;

                Q_ASSERT(sibling < 4);
                node += sibling;
            }

            *channel = i;
            *rect = QRect(quadtreeLocation(node), size);

            return true;
        }
    }

    return false;
}

quadtreeFindExistingLocation()

void QGLMaskTextureCache::quadtreeFindExistingLocation ( const QSize &  size, QRect *  rect, int *  channel  )

private

Definition at line 2981 of file qpaintengine_opengl.cpp.

{
    // try to pick small masks to throw out, as large masks are more expensive to recompute
    *channel = qrand() % 4;
    for (int i = 0; i < 4; ++i)
        if (occupied_quadtree[i][0].largest_used_block < occupied_quadtree[*channel][0].largest_used_block)
            *channel = i;

    int needed_block_size = qt_next_power_of_two(qMax(1, qMax(size.width(), size.height())));

    int node = 0;
    int current_block_size = offscreenSize.width();

    while (current_block_size > block_size
           && current_block_size >= needed_block_size * 2
           && occupied_quadtree[*channel][node].key == 0)
    {
        node = node * 4 + 1;

        int sibling = 0;

        for (int i = 1; i < 4; ++i) {
            if (occupied_quadtree[*channel][node + i].largest_used_block
                <= occupied_quadtree[*channel][node + sibling].largest_used_block)
            {
                sibling = i;
            }
        }

        node += sibling;
        current_block_size /= 2;
    }

    *rect = QRect(quadtreeLocation(node), size);
}

quadtreeInsert()

void QGLMaskTextureCache::quadtreeInsert ( int  channel, quint64  key, const QRect &  rect, int  node = 0  )

private

Definition at line 2850 of file qpaintengine_opengl.cpp.

{
    int current_block_size = quadtreeBlocksize(node);
    QPoint location = quadtreeLocation(node);
    QRect relative = rect.translated(-location);

    if (relative.left() >= current_block_size || relative.top() >= current_block_size
        || relative.right() < 0 || relative.bottom() < 0)
        return;

    if (current_block_size == block_size // no more refining possible
        || (relative.top() < block_size && relative.bottom() >= (current_block_size - block_size)
            && relative.left() < block_size && relative.right() >= (current_block_size - block_size)))
    {
        if (key != 0) {
            occupied_quadtree[channel][node].largest_available_block = 0;
            occupied_quadtree[channel][node].largest_used_block = rect.width() * rect.height();
        } else {
            occupied_quadtree[channel][node].largest_available_block = current_block_size;
            occupied_quadtree[channel][node].largest_used_block = 0;
        }

        occupied_quadtree[channel][node].key = key;

        quadtreeUpdate(channel, node, current_block_size);
    } else {
        if (key && occupied_quadtree[channel][node].largest_available_block == current_block_size) {
            // refining the quad tree, initialize child nodes
            int half_block_size = current_block_size / 2;

            int temp = node * 4 + 1;
            for (int sibling = 0; sibling < 4; ++sibling) {
                occupied_quadtree[channel][temp + sibling].largest_available_block = half_block_size;
                occupied_quadtree[channel][temp + sibling].largest_used_block = 0;
                occupied_quadtree[channel][temp + sibling].key = 0;
            }
        }

        node = node * 4 + 1;

        for (int sibling = 0; sibling < 4; ++sibling)
            quadtreeInsert(channel, key, rect, node + sibling);
    }
}

quadtreeLocation()

QPoint QGLMaskTextureCache::quadtreeLocation ( int  node )

private

Definition at line 2797 of file qpaintengine_opengl.cpp.

{
    QPoint location;
    int blocksize = quadtreeBlocksize(node);

    while (node) {
        --node;

        if (node & 1)
            location.setX(location.x() + blocksize);

        if (node & 2)
            location.setY(location.y() + blocksize);

        node /= 4;
        blocksize *= 2;
    }

    return location;
}

quadtreeUpdate()

void QGLMaskTextureCache::quadtreeUpdate ( int  channel, int  node, int  current_block_size  )

private

Definition at line 2818 of file qpaintengine_opengl.cpp.

{
    while (node) {
        node = (node - 1) / 4;

        int first_child = node * 4 + 1;

        int largest_available = 0;
        int largest_used = 0;

        bool all_empty = true;

        for (int i = 0; i < 4; ++i) {
            largest_available = qMax(largest_available, occupied_quadtree[channel][first_child + i].largest_available_block);
            largest_used = qMax(largest_used, occupied_quadtree[channel][first_child + i].largest_used_block);

            if (occupied_quadtree[channel][first_child + i].largest_available_block < current_block_size)
                all_empty = false;
        }

        current_block_size *= 2;

        if (all_empty) {
            occupied_quadtree[channel][node].largest_available_block = current_block_size;
            occupied_quadtree[channel][node].largest_used_block = 0;
        } else {
            occupied_quadtree[channel][node].largest_available_block = largest_available;
            occupied_quadtree[channel][node].largest_used_block = largest_used;
        }
    }
}

setDrawableSize()

void QGLMaskTextureCache::setDrawableSize

(

const QSize &

drawableSize

)

Definition at line 2663 of file qpaintengine_opengl.cpp.

{
    drawableSize = sz;
}

setOffscreenSize()

void QGLMaskTextureCache::setOffscreenSize

(

const QSize &

offscreenSize

)

Definition at line 2633 of file qpaintengine_opengl.cpp.

{
    Q_ASSERT(sz.width() == sz.height());

    if (offscreenSize != sz) {
        offscreenSize = sz;
        clearCache();
    }
}

Properties

cache

QGLTextureCacheHash QGLMaskTextureCache::cache

private

Definition at line 214 of file qpaintengine_opengl.cpp.

drawableSize

QSize QGLMaskTextureCache::drawableSize

private

Definition at line 212 of file qpaintengine_opengl.cpp.

engine

QOpenGLPaintEnginePrivate* QGLMaskTextureCache::engine

private

Definition at line 230 of file qpaintengine_opengl.cpp.

occupied_quadtree

QVector<QuadTreeNode> QGLMaskTextureCache::occupied_quadtree[4]

private

Definition at line 216 of file qpaintengine_opengl.cpp.

offscreenSize

QSize QGLMaskTextureCache::offscreenSize

private

Definition at line 211 of file qpaintengine_opengl.cpp.

---

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

• /src/opengl/qpaintengine_opengl.cpp