diff options
Diffstat (limited to 'src/quick/scenegraph/qsgshareddistancefieldglyphcache.cpp')
| -rw-r--r-- | src/quick/scenegraph/qsgshareddistancefieldglyphcache.cpp | 621 |
1 files changed, 621 insertions, 0 deletions
diff --git a/src/quick/scenegraph/qsgshareddistancefieldglyphcache.cpp b/src/quick/scenegraph/qsgshareddistancefieldglyphcache.cpp new file mode 100644 index 0000000000..841322e58b --- /dev/null +++ b/src/quick/scenegraph/qsgshareddistancefieldglyphcache.cpp @@ -0,0 +1,621 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#define EGL_EGLEXT_PROTOTYPES +#define GL_GLEXT_PROTOTYPES +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG) +#include <GLES2/gl2.h> +#include <GLES2/gl2ext.h> +#endif + +#include "qsgshareddistancefieldglyphcache_p.h" + +#include <QtCore/qhash.h> +#include <QtCore/qthread.h> +#include <QtGui/qplatformsharedgraphicscache_qpa.h> + +#include <QtQuick/qquickcanvas.h> + +#include <QtOpenGL/qglframebufferobject.h> + +// #define QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG + +Q_DECLARE_METATYPE(QVector<quint32>) +Q_DECLARE_METATYPE(QVector<QImage>) + +QT_BEGIN_NAMESPACE + +QSGSharedDistanceFieldGlyphCache::QSGSharedDistanceFieldGlyphCache(const QByteArray &cacheId, + QPlatformSharedGraphicsCache *sharedGraphicsCache, + QSGDistanceFieldGlyphCacheManager *man, + QOpenGLContext *c, + const QRawFont &font) + : QSGDistanceFieldGlyphCache(man, c, font) + , m_cacheId(cacheId) + , m_sharedGraphicsCache(sharedGraphicsCache) +{ +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG) + qDebug("QSGSharedDistanceFieldGlyphCache with id %s created in thread %p", + cacheId.constData(), QThread::currentThreadId()); +#endif + + Q_ASSERT(sizeof(glyph_t) == sizeof(quint32)); + Q_ASSERT(sharedGraphicsCache != 0); + + qRegisterMetaType<QVector<quint32> >(); + qRegisterMetaType<QVector<QImage> >(); + + connect(sharedGraphicsCache, SIGNAL(itemsMissing(QByteArray,QVector<quint32>)), + this, SLOT(reportItemsMissing(QByteArray,QVector<quint32>)), + Qt::DirectConnection); + connect(sharedGraphicsCache, SIGNAL(itemsAvailable(QByteArray,void*,QSize,QVector<quint32>,QVector<QPoint>)), + this, SLOT(reportItemsAvailable(QByteArray,void*,QSize,QVector<quint32>,QVector<QPoint>)), + Qt::DirectConnection); + connect(sharedGraphicsCache, SIGNAL(itemsUpdated(QByteArray,void*,QSize,QVector<quint32>,QVector<QPoint>)), + this, SLOT(reportItemsAvailable(QByteArray,void*,QSize,QVector<quint32>,QVector<QPoint>)), + Qt::DirectConnection); + connect(sharedGraphicsCache, SIGNAL(itemsInvalidated(QByteArray,QVector<quint32>)), + this, SLOT(reportItemsInvalidated(QByteArray,QVector<quint32>)), + Qt::DirectConnection); +} + +QSGSharedDistanceFieldGlyphCache::~QSGSharedDistanceFieldGlyphCache() +{ + { + QHash<glyph_t, void *>::const_iterator it = m_bufferForGlyph.constBegin(); + while (it != m_bufferForGlyph.constEnd()) { + m_sharedGraphicsCache->dereferenceBuffer(it.value()); + ++it; + } + } + + { + QHash<quint32, PendingGlyph>::const_iterator it = m_pendingReadyGlyphs.constBegin(); + while (it != m_pendingReadyGlyphs.constEnd()) { + m_sharedGraphicsCache->dereferenceBuffer(it.value().buffer); + ++it; + } + } +} + +void QSGSharedDistanceFieldGlyphCache::requestGlyphs(const QSet<glyph_t> &glyphs) +{ + QMutexLocker locker(&m_pendingGlyphsMutex); + +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG) + qDebug("QSGSharedDistanceFieldGlyphCache::requestGlyphs() called for %s (%d glyphs)", + m_cacheId.constData(), glyphs.size()); +#endif + + m_requestedGlyphsThatHaveNotBeenReturned.unite(glyphs); + + QVector<quint32> glyphsVector; + glyphsVector.reserve(glyphs.size()); + + QSet<glyph_t>::const_iterator it; + for (it = glyphs.constBegin(); it != glyphs.constEnd(); ++it) { + Q_ASSERT(!m_bufferForGlyph.contains(*it)); + glyphsVector.append(*it); + } + + // Invoke method on queued connection to make sure it's called asynchronously on the + // correct thread (requestGlyphs() is called from the rendering thread.) + QMetaObject::invokeMethod(m_sharedGraphicsCache, "requestItems", Qt::QueuedConnection, + Q_ARG(QByteArray, m_cacheId), + Q_ARG(QVector<quint32>, glyphsVector)); +} + +void QSGSharedDistanceFieldGlyphCache::waitForGlyphs() +{ + { + QMutexLocker locker(&m_pendingGlyphsMutex); + while (!m_requestedGlyphsThatHaveNotBeenReturned.isEmpty()) + m_pendingGlyphsCondition.wait(&m_pendingGlyphsMutex); + } +} + +void QSGSharedDistanceFieldGlyphCache::storeGlyphs(const QHash<glyph_t, QImage> &glyphs) +{ + { + QMutexLocker locker(&m_pendingGlyphsMutex); +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG) + qDebug("QSGSharedDistanceFieldGlyphCache::storeGlyphs() called for %s (%d glyphs)", + m_cacheId.constData(), glyphs.size()); +#endif + + int glyphCount = glyphs.size(); + QVector<quint32> glyphIds(glyphCount); + QVector<QImage> images(glyphCount); + QHash<glyph_t, QImage>::const_iterator it = glyphs.constBegin(); + int i=0; + while (it != glyphs.constEnd()) { + m_requestedGlyphsThatHaveNotBeenReturned.insert(it.key()); + glyphIds[i] = it.key(); + images[i] = it.value(); + + ++it; ++i; + } + + QMetaObject::invokeMethod(m_sharedGraphicsCache, "insertItems", Qt::QueuedConnection, + Q_ARG(QByteArray, m_cacheId), + Q_ARG(QVector<quint32>, glyphIds), + Q_ARG(QVector<QImage>, images)); + } + + processPendingGlyphs(); +} + +void QSGSharedDistanceFieldGlyphCache::referenceGlyphs(const QSet<glyph_t> &glyphs) +{ + Q_UNUSED(glyphs); + + // Intentionally empty. Not required in this implementation, since the glyphs are reference + // counted outside and releaseGlyphs() will only be called when there are no more references. +} + +void QSGSharedDistanceFieldGlyphCache::releaseGlyphs(const QSet<glyph_t> &glyphs) +{ +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG) + qDebug("QSGSharedDistanceFieldGlyphCache::releaseGlyphs() called for %s (%d glyphs)", + m_cacheId.constData(), glyphs.size()); +#endif + + QVector<quint32> glyphsVector; + glyphsVector.reserve(glyphs.size()); + + QSet<glyph_t>::const_iterator glyphsIt; + for (glyphsIt = glyphs.constBegin(); glyphsIt != glyphs.constEnd(); ++glyphsIt) { + QHash<glyph_t, void *>::iterator bufferIt = m_bufferForGlyph.find(*glyphsIt); + if (bufferIt != m_bufferForGlyph.end()) { + void *buffer = bufferIt.value(); + removeGlyph(*glyphsIt); + m_bufferForGlyph.erase(bufferIt); + Q_ASSERT(!m_bufferForGlyph.contains(*glyphsIt)); + + if (!m_sharedGraphicsCache->dereferenceBuffer(buffer)) { +#if !defined(QT_NO_DEBUG) + bufferIt = m_bufferForGlyph.begin(); + while (bufferIt != m_bufferForGlyph.end()) { + Q_ASSERT(bufferIt.value() != buffer); + ++bufferIt; + } +#endif + } + } + + glyphsVector.append(*glyphsIt); + } + + QMetaObject::invokeMethod(m_sharedGraphicsCache, "releaseItems", Qt::QueuedConnection, + Q_ARG(QByteArray, m_cacheId), + Q_ARG(QVector<quint32>, glyphsVector)); +} + +void QSGSharedDistanceFieldGlyphCache::registerOwnerElement(QQuickItem *ownerElement) +{ + bool ok = connect(this, SIGNAL(glyphsPending()), ownerElement, SLOT(triggerPreprocess())); + Q_ASSERT_X(ok, Q_FUNC_INFO, "QML element that owns a glyph node must have triggerPreprocess() slot"); + Q_UNUSED(ok); +} + +void QSGSharedDistanceFieldGlyphCache::unregisterOwnerElement(QQuickItem *ownerElement) +{ + disconnect(this, SIGNAL(glyphsPending()), ownerElement, SLOT(triggerPreprocess())); +} + +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG_) +# include <QtOpenGL/private/qglextensions_p.h> + +void QSGSharedDistanceFieldGlyphCache::saveTexture(GLuint textureId, int width, int height) +{ + GLuint fboId; + glGenFramebuffers(1, &fboId); + + GLuint tmpTexture = 0; + glGenTextures(1, &tmpTexture); + glBindTexture(GL_TEXTURE_2D, tmpTexture); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glBindTexture(GL_TEXTURE_2D, 0); + + glBindFramebuffer(GL_FRAMEBUFFER_EXT, fboId); + glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, + tmpTexture, 0); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, textureId); + + glDisable(GL_STENCIL_TEST); + glDisable(GL_DEPTH_TEST); + glDisable(GL_SCISSOR_TEST); + glDisable(GL_BLEND); + + GLfloat textureCoordinateArray[8]; + textureCoordinateArray[0] = 0.0f; + textureCoordinateArray[1] = 0.0f; + textureCoordinateArray[2] = 1.0f; + textureCoordinateArray[3] = 0.0f; + textureCoordinateArray[4] = 1.0f; + textureCoordinateArray[5] = 1.0f; + textureCoordinateArray[6] = 0.0f; + textureCoordinateArray[7] = 1.0f; + + GLfloat vertexCoordinateArray[8]; + vertexCoordinateArray[0] = -1.0f; + vertexCoordinateArray[1] = -1.0f; + vertexCoordinateArray[2] = 1.0f; + vertexCoordinateArray[3] = -1.0f; + vertexCoordinateArray[4] = 1.0f; + vertexCoordinateArray[5] = 1.0f; + vertexCoordinateArray[6] = -1.0f; + vertexCoordinateArray[7] = 1.0f; + + glViewport(0, 0, width, height); + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray); + + { + static const char *vertexShaderSource = + "attribute highp vec4 vertexCoordsArray; \n" + "attribute highp vec2 textureCoordArray; \n" + "varying highp vec2 textureCoords; \n" + "void main(void) \n" + "{ \n" + " gl_Position = vertexCoordsArray; \n" + " textureCoords = textureCoordArray; \n" + "} \n"; + + static const char *fragmentShaderSource = + "varying highp vec2 textureCoords; \n" + "uniform sampler2D texture; \n" + "void main() \n" + "{ \n" + " gl_FragColor = texture2D(texture, textureCoords); \n" + "} \n"; + + GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); + GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); + + if (vertexShader == 0 || fragmentShader == 0) { + GLenum error = glGetError(); + qWarning("SharedGraphicsCacheServer::setupShaderPrograms: Failed to create shaders. (GL error: %x)", + error); + return; + } + + glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); + glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); + glCompileShader(vertexShader); + + GLint len = 1; + glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &len); + + char infoLog[2048]; + glGetShaderInfoLog(vertexShader, 2048, NULL, infoLog); + if (qstrlen(infoLog) > 0) { + qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems compiling vertex shader:\n %s", + infoLog); + //return; + } + + glCompileShader(fragmentShader); + glGetShaderInfoLog(fragmentShader, 2048, NULL, infoLog); + if (qstrlen(infoLog) > 0) { + qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems compiling fragent shader:\n %s", + infoLog); + //return; + } + + GLuint shaderProgram = glCreateProgram(); + glAttachShader(shaderProgram, vertexShader); + glAttachShader(shaderProgram, fragmentShader); + + glBindAttribLocation(shaderProgram, 0, "vertexCoordsArray"); + glBindAttribLocation(shaderProgram, 1, "textureCoordArray"); + + glLinkProgram(shaderProgram); + glGetProgramInfoLog(shaderProgram, 2048, NULL, infoLog); + if (qstrlen(infoLog) > 0) { + qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems linking shaders:\n %s", + infoLog); + //return; + } + + glUseProgram(shaderProgram); + glEnableVertexAttribArray(0); + glEnableVertexAttribArray(1); + + int textureUniformLocation = glGetUniformLocation(shaderProgram, "texture"); + glUniform1i(textureUniformLocation, 0); + } + + glDrawArrays(GL_TRIANGLE_FAN, 0, 4); + + { + GLenum error = glGetError(); + if (error != GL_NO_ERROR) { + qWarning("SharedGraphicsCacheServer::readBackBuffer: glDrawArrays reported error 0x%x", + error); + } + } + + uchar *data = new uchar[width * height * 4]; + + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data); + + QImage image(width, height, QImage::Format_ARGB32); + quint32 *dest = reinterpret_cast<quint32 *>(image.bits()); + for (int i=0; i<width*height; ++i) + dest[i] = qRgba(0xff, 0xff, 0xff, data[i]); + + QByteArray fileName = m_cacheId + " " + QByteArray::number(textureId); + fileName = fileName.replace('/', '_').replace(' ', '_') + ".png"; + image.save(QString::fromLocal8Bit(fileName)); + + { + GLenum error = glGetError(); + if (error != GL_NO_ERROR) { + qWarning("SharedGraphicsCacheServer::readBackBuffer: glReadPixels reported error 0x%x", + error); + } + } + + glDisableVertexAttribArray(0); + glDisableVertexAttribArray(1); + + glDeleteFramebuffers(1, &fboId); + glDeleteTextures(1, &tmpTexture); + + delete[] data; +} +#endif + +namespace { + struct TextureContent { + QSize size; + QVector<glyph_t> glyphs; + }; +} + +void QSGSharedDistanceFieldGlyphCache::processPendingGlyphs() +{ + Q_ASSERT(QThread::currentThread() == thread()); + + waitForGlyphs(); + + { + QMutexLocker locker(&m_pendingGlyphsMutex); + if (m_pendingMissingGlyphs.isEmpty() + && m_pendingReadyGlyphs.isEmpty() + && m_pendingInvalidatedGlyphs.isEmpty()) { + return; + } + + { + QVector<glyph_t> pendingMissingGlyphs; + pendingMissingGlyphs.reserve(m_pendingMissingGlyphs.size()); + + QSet<glyph_t>::const_iterator it = m_pendingMissingGlyphs.constBegin(); + while (it != m_pendingMissingGlyphs.constEnd()) { + pendingMissingGlyphs.append(*it); + ++it; + } + + markGlyphsToRender(pendingMissingGlyphs); + } + + { + QVector<glyph_t> filteredPendingInvalidatedGlyphs; + filteredPendingInvalidatedGlyphs.reserve(m_pendingInvalidatedGlyphs.size()); + + QSet<glyph_t>::const_iterator it = m_pendingInvalidatedGlyphs.constBegin(); + while (it != m_pendingInvalidatedGlyphs.constEnd()) { + bool rerequestGlyph = false; + + // The glyph was invalidated right after being posted as ready, we throw away + // the ready glyph and rerequest it to be certain + QHash<quint32, PendingGlyph>::iterator pendingGlyphIt = m_pendingReadyGlyphs.find(*it); + if (pendingGlyphIt != m_pendingReadyGlyphs.end()) { + m_sharedGraphicsCache->dereferenceBuffer(pendingGlyphIt.value().buffer); + pendingGlyphIt = m_pendingReadyGlyphs.erase(pendingGlyphIt); + rerequestGlyph = true; + } + + void *bufferId = m_bufferForGlyph.value(*it, 0); + if (bufferId != 0) { + m_sharedGraphicsCache->dereferenceBuffer(bufferId); + m_bufferForGlyph.remove(*it); + rerequestGlyph = true; + } + + if (rerequestGlyph) + filteredPendingInvalidatedGlyphs.append(*it); + + ++it; + } + + // If this cache is still using the glyphs, reset the texture held by them, and mark them + // to be rendered again since they are still needed. + if (!filteredPendingInvalidatedGlyphs.isEmpty()) { + setGlyphsTexture(filteredPendingInvalidatedGlyphs, Texture()); + markGlyphsToRender(filteredPendingInvalidatedGlyphs); + } + } + + { + QList<GlyphPosition> glyphPositions; + + QHash<void *, TextureContent> textureContentForBuffer; + { + QHash<quint32, PendingGlyph>::iterator it = m_pendingReadyGlyphs.begin(); + while (it != m_pendingReadyGlyphs.end()) { + void *currentGlyphBuffer = m_bufferForGlyph.value(it.key(), 0); + if (currentGlyphBuffer != 0) { + if (!m_sharedGraphicsCache->dereferenceBuffer(currentGlyphBuffer)) { + Q_ASSERT(!textureContentForBuffer.contains(currentGlyphBuffer)); + } + } + + PendingGlyph &pendingGlyph = it.value(); + + // We don't ref or deref the buffer here, since it was already referenced when + // added to the pending ready glyphs + m_bufferForGlyph[it.key()] = pendingGlyph.buffer; + + textureContentForBuffer[pendingGlyph.buffer].size = pendingGlyph.bufferSize; + textureContentForBuffer[pendingGlyph.buffer].glyphs.append(it.key()); + + GlyphPosition glyphPosition; + glyphPosition.glyph = it.key(); + glyphPosition.position = pendingGlyph.position; + + glyphPositions.append(glyphPosition); + + ++it; + } + } + + setGlyphsPosition(glyphPositions); + + { + QHash<void *, TextureContent>::const_iterator it = textureContentForBuffer.constBegin(); + while (it != textureContentForBuffer.constEnd()) { + Texture texture; + texture.textureId = m_sharedGraphicsCache->textureIdForBuffer(it.key()); + texture.size = it.value().size; + +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG_) + saveTexture(texture.textureId, texture.size.width(), texture.size.height()); +#endif + setGlyphsTexture(it.value().glyphs, texture); + + ++it; + } + } + } + + m_pendingMissingGlyphs.clear(); + m_pendingInvalidatedGlyphs.clear(); + m_pendingReadyGlyphs.clear(); + } +} + +void QSGSharedDistanceFieldGlyphCache::reportItemsAvailable(const QByteArray &cacheId, + void *bufferId, const QSize &bufferSize, + const QVector<quint32> &itemIds, + const QVector<QPoint> &positions) +{ + { + QMutexLocker locker(&m_pendingGlyphsMutex); + if (m_cacheId != cacheId) + return; + + Q_ASSERT(itemIds.size() == positions.size()); + +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG) + qDebug("QSGSharedDistanceFieldGlyphCache::reportItemsAvailable() called for %s (%d glyphs, bufferSize: %dx%d)", + cacheId.constData(), itemIds.size(), bufferSize.width(), bufferSize.height()); +#endif + + for (int i=0; i<itemIds.size(); ++i) { + PendingGlyph &pendingGlyph = m_pendingReadyGlyphs[itemIds.at(i)]; + void *oldBuffer = pendingGlyph.buffer; + Q_ASSERT(bufferSize.height() >= pendingGlyph.bufferSize.height()); + + pendingGlyph.buffer = bufferId; + pendingGlyph.position = positions.at(i); + pendingGlyph.bufferSize = bufferSize; + + m_sharedGraphicsCache->referenceBuffer(bufferId); + if (oldBuffer != 0) + m_sharedGraphicsCache->dereferenceBuffer(oldBuffer); + + m_requestedGlyphsThatHaveNotBeenReturned.remove(itemIds.at(i)); + } + } + + m_pendingGlyphsCondition.wakeAll(); + emit glyphsPending(); +} + +void QSGSharedDistanceFieldGlyphCache::reportItemsInvalidated(const QByteArray &cacheId, + const QVector<quint32> &itemIds) +{ + { + QMutexLocker locker(&m_pendingGlyphsMutex); + if (m_cacheId != cacheId) + return; + + for (int i=0; i<itemIds.size(); ++i) + m_pendingInvalidatedGlyphs.insert(itemIds.at(i)); + } + + emit glyphsPending(); +} + + +void QSGSharedDistanceFieldGlyphCache::reportItemsMissing(const QByteArray &cacheId, + const QVector<quint32> &itemIds) +{ + { + QMutexLocker locker(&m_pendingGlyphsMutex); + if (m_cacheId != cacheId) + return; + +#if defined(QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG) + qDebug("QSGSharedDistanceFieldGlyphCache::reportItemsMissing() called for %s (%d glyphs)", + cacheId.constData(), itemIds.size()); +#endif + + for (int i=0; i<itemIds.size(); ++i) { + m_pendingMissingGlyphs.insert(itemIds.at(i)); + m_requestedGlyphsThatHaveNotBeenReturned.remove(itemIds.at(i)); + } + } + + m_pendingGlyphsCondition.wakeAll(); + emit glyphsPending(); +} + +QT_END_NAMESPACE |