Revision control
++ // Copyright (C) 2019 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qsgrhidistancefieldglyphcache_p.h"
++ #include "qsgcontext_p.h"
++ #include "qsgdefaultrendercontext_p.h"
++ #include <QtGui/private/qdistancefield_p.h>
++ #include <QtCore/qelapsedtimer.h>
++ #include <QtQml/private/qqmlglobal_p.h>
++ #include <qmath.h>
++ #include <qendian.h>
++
++ QT_BEGIN_NAMESPACE
++
++ DEFINE_BOOL_CONFIG_OPTION(qmlUseGlyphCacheWorkaround, QML_USE_GLYPHCACHE_WORKAROUND)
++ DEFINE_BOOL_CONFIG_OPTION(qsgPreferFullSizeGlyphCacheTextures, QSG_PREFER_FULLSIZE_GLYPHCACHE_TEXTURES)
++
++ #if !defined(QSG_RHI_DISTANCEFIELD_GLYPH_CACHE_PADDING)
++ # define QSG_RHI_DISTANCEFIELD_GLYPH_CACHE_PADDING 2
++ #endif
++
++ QSGRhiDistanceFieldGlyphCache::QSGRhiDistanceFieldGlyphCache(QSGDefaultRenderContext *rc,
++ const QRawFont &font,
++ int renderTypeQuality)
++ : QSGDistanceFieldGlyphCache(font, renderTypeQuality)
++ , m_rc(rc)
++ , m_rhi(rc->rhi())
++ {
++ // Load a pregenerated cache if the font contains one
++ loadPregeneratedCache(font);
++ }
++
++ QSGRhiDistanceFieldGlyphCache::~QSGRhiDistanceFieldGlyphCache()
++ {
++ for (const TextureInfo &t : std::as_const(m_textures))
++ m_rc->deferredReleaseGlyphCacheTexture(t.texture);
++
++ delete m_areaAllocator;
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::requestGlyphs(const QSet<glyph_t> &glyphs)
++ {
++ QList<GlyphPosition> glyphPositions;
++ QList<glyph_t> glyphsToRender;
++
++ if (m_areaAllocator == nullptr)
++ m_areaAllocator = new QSGAreaAllocator(QSize(maxTextureSize(), m_maxTextureCount * maxTextureSize()),
++ maxTextureSize());
++
++ for (QSet<glyph_t>::const_iterator it = glyphs.constBegin(); it != glyphs.constEnd() ; ++it) {
++ glyph_t glyphIndex = *it;
++
++ int padding = QSG_RHI_DISTANCEFIELD_GLYPH_CACHE_PADDING;
++ QRectF boundingRect = glyphData(glyphIndex).boundingRect;
++ int glyphWidth = qCeil(boundingRect.width() + distanceFieldRadius() * 2);
++ int glyphHeight = qCeil(boundingRect.height() + distanceFieldRadius() * 2);
++ QSize glyphSize(glyphWidth + padding * 2, glyphHeight + padding * 2);
++ QRect alloc = m_areaAllocator->allocate(glyphSize);
++
++ if (alloc.isNull()) {
++ // Unallocate unused glyphs until we can allocated the new glyph
++ while (alloc.isNull() && !m_unusedGlyphs.isEmpty()) {
++ glyph_t unusedGlyph = *m_unusedGlyphs.constBegin();
++
++ TexCoord unusedCoord = glyphTexCoord(unusedGlyph);
++ if (!unusedCoord.isNull()) {
++ QRectF unusedGlyphBoundingRect = glyphData(unusedGlyph).boundingRect;
++ int unusedGlyphWidth = qCeil(unusedGlyphBoundingRect.width() + distanceFieldRadius() * 2);
++ int unusedGlyphHeight = qCeil(unusedGlyphBoundingRect.height() + distanceFieldRadius() * 2);
++ m_areaAllocator->deallocate(QRect(unusedCoord.x - padding,
++ unusedCoord.y - padding,
++ padding * 2 + unusedGlyphWidth,
++ padding * 2 + unusedGlyphHeight));
++ }
++
++ m_unusedGlyphs.remove(unusedGlyph);
++ m_glyphsTexture.remove(unusedGlyph);
++ removeGlyph(unusedGlyph);
++
++ alloc = m_areaAllocator->allocate(glyphSize);
++ }
++
++ // Not enough space left for this glyph... skip to the next one
++ if (alloc.isNull())
++ continue;
++ }
++
++ TextureInfo *tex = textureInfo(alloc.y() / maxTextureSize());
++ alloc = QRect(alloc.x(), alloc.y() % maxTextureSize(), alloc.width(), alloc.height());
++ Q_ASSERT(alloc.bottom() < maxTextureSize());
++
++ tex->allocatedArea |= alloc;
++ Q_ASSERT(tex->padding == padding || tex->padding < 0);
++ tex->padding = padding;
++
++ GlyphPosition p;
++ p.glyph = glyphIndex;
++ p.position = alloc.topLeft() + QPoint(padding, padding);
++
++ glyphPositions.append(p);
++ glyphsToRender.append(glyphIndex);
++ m_glyphsTexture.insert(glyphIndex, tex);
++ }
++
++ setGlyphsPosition(glyphPositions);
++ markGlyphsToRender(glyphsToRender);
++ }
++
++ bool QSGRhiDistanceFieldGlyphCache::isActive() const
++ {
++ return !m_referencedGlyphs.empty();
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::storeGlyphs(const QList<QDistanceField> &glyphs)
++ {
++ typedef QHash<TextureInfo *, QList<glyph_t> > GlyphTextureHash;
++ typedef GlyphTextureHash::const_iterator GlyphTextureHashConstIt;
++
++ GlyphTextureHash glyphTextures;
++
++ for (int i = 0; i < glyphs.size(); ++i) {
++ QDistanceField glyph = glyphs.at(i);
++ glyph_t glyphIndex = glyph.glyph();
++ TexCoord c = glyphTexCoord(glyphIndex);
++ TextureInfo *texInfo = m_glyphsTexture.value(glyphIndex);
++
++ resizeTexture(texInfo, texInfo->allocatedArea.width(), texInfo->allocatedArea.height());
++
++ if (!texInfo->texture)
++ continue;
++
++ glyphTextures[texInfo].append(glyphIndex);
++
++ int padding = texInfo->padding;
++ int expectedWidth = qCeil(c.width + c.xMargin * 2);
++ glyph = glyph.copy(-padding, -padding,
++ expectedWidth + padding * 2, glyph.height() + padding * 2);
++
++ if (useTextureResizeWorkaround()) {
++ uchar *inBits = glyph.scanLine(0);
++ uchar *outBits = texInfo->image.scanLine(int(c.y) - padding) + int(c.x) - padding;
++ for (int y = 0; y < glyph.height(); ++y) {
++ memcpy(outBits, inBits, glyph.width());
++ inBits += glyph.width();
++ outBits += texInfo->image.width();
++ }
++ }
++
++ QRhiTextureSubresourceUploadDescription subresDesc(glyph.constBits(), glyph.width() * glyph.height());
++ subresDesc.setSourceSize(QSize(glyph.width(), glyph.height()));
++ subresDesc.setDestinationTopLeft(QPoint(c.x - padding, c.y - padding));
++ texInfo->uploads.append(QRhiTextureUploadEntry(0, 0, subresDesc));
++ }
++
++ QRhiResourceUpdateBatch *resourceUpdates = m_rc->glyphCacheResourceUpdates();
++ for (int i = 0; i < glyphs.size(); ++i) {
++ TextureInfo *texInfo = m_glyphsTexture.value(glyphs.at(i).glyph());
++ if (!texInfo->uploads.isEmpty() && texInfo->texture) {
++ QRhiTextureUploadDescription desc;
++ desc.setEntries(texInfo->uploads.cbegin(), texInfo->uploads.cend());
++ resourceUpdates->uploadTexture(texInfo->texture, desc);
++ texInfo->uploads.clear();
++ }
++ }
++
++ for (GlyphTextureHashConstIt i = glyphTextures.constBegin(), cend = glyphTextures.constEnd(); i != cend; ++i) {
++ Texture t;
++ t.texture = i.key()->texture;
++ t.size = i.key()->size;
++ setGlyphsTexture(i.value(), t);
++ }
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::referenceGlyphs(const QSet<glyph_t> &glyphs)
++ {
++ m_referencedGlyphs += glyphs;
++ m_unusedGlyphs -= glyphs;
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::releaseGlyphs(const QSet<glyph_t> &glyphs)
++ {
++ m_referencedGlyphs -= glyphs;
++ m_unusedGlyphs += glyphs;
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::createTexture(TextureInfo *texInfo,
++ int width,
++ int height)
++ {
++ QByteArray zeroBuf(width * height, 0);
++ createTexture(texInfo, width, height, zeroBuf.constData());
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::createTexture(TextureInfo *texInfo,
++ int width,
++ int height,
++ const void *pixels)
++ {
++ QRhiTexture *newTexture = m_rhi->newTexture(QRhiTexture::RED_OR_ALPHA8, QSize(width, height), 1, QRhiTexture::UsedAsTransferSource);
++ if (!newTexture->create()) {
++ qWarning("Failed to create distance field glyph cache");
++ delete newTexture;
++ texInfo->texture = nullptr;
++ texInfo->size = QSize();
++ texInfo->image = QDistanceField();
++ return;
++ }
++
++ if (useTextureResizeWorkaround() && texInfo->image.isNull()) {
++ texInfo->image = QDistanceField(width, height);
++ memcpy(texInfo->image.bits(), pixels, width * height);
++ }
++
++ texInfo->texture = newTexture;
++ texInfo->size = QSize(width, height);
++
++ QRhiResourceUpdateBatch *resourceUpdates = m_rc->glyphCacheResourceUpdates();
++ QRhiTextureSubresourceUploadDescription subresDesc(pixels, width * height);
++ subresDesc.setSourceSize(QSize(width, height));
++ resourceUpdates->uploadTexture(texInfo->texture, QRhiTextureUploadEntry(0, 0, subresDesc));
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::resizeTexture(TextureInfo *texInfo, int width, int height)
++ {
++ int oldWidth = texInfo->size.width();
++ int oldHeight = texInfo->size.height();
++ if (width == oldWidth && height == oldHeight)
++ return;
++
++ QRhiTexture *oldTexture = texInfo->texture;
++ createTexture(texInfo, width, height);
++
++ if (!texInfo->texture) {
++ if (oldTexture)
++ m_rc->deferredReleaseGlyphCacheTexture(oldTexture);
++ return;
++ }
++
++ if (!oldTexture)
++ return;
++
++ updateRhiTexture(oldTexture, texInfo->texture, texInfo->size);
++
++ QRhiResourceUpdateBatch *resourceUpdates = m_rc->glyphCacheResourceUpdates();
++ if (useTextureResizeWorkaround()) {
++ QRhiTextureSubresourceUploadDescription subresDesc(texInfo->image.constBits(),
++ oldWidth * oldHeight);
++ subresDesc.setSourceSize(QSize(oldWidth, oldHeight));
++ resourceUpdates->uploadTexture(texInfo->texture, QRhiTextureUploadEntry(0, 0, subresDesc));
++ texInfo->image = texInfo->image.copy(0, 0, width, height);
++ } else {
++ resourceUpdates->copyTexture(texInfo->texture, oldTexture);
++ }
++
++ m_rc->deferredReleaseGlyphCacheTexture(oldTexture);
++ }
++
++ bool QSGRhiDistanceFieldGlyphCache::useTextureResizeWorkaround() const
++ {
++ static bool set = false;
++ static bool useWorkaround = false;
++ if (!set) {
++ useWorkaround = m_rhi->backend() == QRhi::OpenGLES2 || qmlUseGlyphCacheWorkaround();
++ set = true;
++ }
++ return useWorkaround;
++ }
++
++ bool QSGRhiDistanceFieldGlyphCache::createFullSizeTextures() const
++ {
++ return qsgPreferFullSizeGlyphCacheTextures() && glyphCount() > QT_DISTANCEFIELD_HIGHGLYPHCOUNT();
++ }
++
++ int QSGRhiDistanceFieldGlyphCache::maxTextureSize() const
++ {
++ if (!m_maxTextureSize)
++ m_maxTextureSize = m_rhi->resourceLimit(QRhi::TextureSizeMax);
++ return m_maxTextureSize;
++ }
++
++ namespace {
++ struct Qtdf {
++ // We need these structs to be tightly packed, but some compilers we use do not
++ // support #pragma pack(1), so we need to hardcode the offsets/sizes in the
++ // file format
++ enum TableSize {
++ HeaderSize = 14,
++ GlyphRecordSize = 46,
++ TextureRecordSize = 17
++ };
++
++ enum Offset {
++ // Header
++ majorVersion = 0,
++ minorVersion = 1,
++ pixelSize = 2,
++ textureSize = 4,
++ flags = 8,
++ headerPadding = 9,
++ numGlyphs = 10,
++
++ // Glyph record
++ glyphIndex = 0,
++ textureOffsetX = 4,
++ textureOffsetY = 8,
++ textureWidth = 12,
++ textureHeight = 16,
++ xMargin = 20,
++ yMargin = 24,
++ boundingRectX = 28,
++ boundingRectY = 32,
++ boundingRectWidth = 36,
++ boundingRectHeight = 40,
++ textureIndex = 44,
++
++ // Texture record
++ allocatedX = 0,
++ allocatedY = 4,
++ allocatedWidth = 8,
++ allocatedHeight = 12,
++ texturePadding = 16
++
++ };
++
++ template <typename T>
++ static inline T fetch(const char *data, Offset offset)
++ {
++ return qFromBigEndian<T>(data + int(offset));
++ }
++ };
++ }
++
++ bool QSGRhiDistanceFieldGlyphCache::loadPregeneratedCache(const QRawFont &font)
++ {
++ // The pregenerated data must be loaded first, otherwise the area allocator
++ // will be wrong
++ if (m_areaAllocator != nullptr) {
++ qWarning("Font cache must be loaded before cache is used");
++ return false;
++ }
++
++ static QElapsedTimer timer;
++
++ bool profile = QSG_LOG_TIME_GLYPH().isDebugEnabled();
++ if (profile)
++ timer.start();
++
++ QByteArray qtdfTable = font.fontTable("qtdf");
++ if (qtdfTable.isEmpty())
++ return false;
++
++ typedef QHash<TextureInfo *, QList<glyph_t> > GlyphTextureHash;
++
++ GlyphTextureHash glyphTextures;
++
++ if (uint(qtdfTable.size()) < Qtdf::HeaderSize) {
++ qWarning("Invalid qtdf table in font '%s'",
++ qPrintable(font.familyName()));
++ return false;
++ }
++
++ const char *qtdfTableStart = qtdfTable.constData();
++ const char *qtdfTableEnd = qtdfTableStart + qtdfTable.size();
++
++ int padding = 0;
++ int textureCount = 0;
++ {
++ quint8 majorVersion = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::majorVersion);
++ quint8 minorVersion = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::minorVersion);
++ if (majorVersion != 5 || minorVersion != 12) {
++ qWarning("Invalid version of qtdf table %d.%d in font '%s'",
++ majorVersion,
++ minorVersion,
++ qPrintable(font.familyName()));
++ return false;
++ }
++
++ qreal pixelSize = qreal(Qtdf::fetch<quint16>(qtdfTableStart, Qtdf::pixelSize));
++ m_maxTextureSize = Qtdf::fetch<quint32>(qtdfTableStart, Qtdf::textureSize);
++ m_doubleGlyphResolution = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::flags) == 1;
++ padding = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::headerPadding);
++
++ if (pixelSize <= 0.0) {
++ qWarning("Invalid pixel size in '%s'", qPrintable(font.familyName()));
++ return false;
++ }
++
++ if (m_maxTextureSize <= 0) {
++ qWarning("Invalid texture size in '%s'", qPrintable(font.familyName()));
++ return false;
++ }
++
++ int systemMaxTextureSize = m_rhi->resourceLimit(QRhi::TextureSizeMax);
++
++ if (m_maxTextureSize > systemMaxTextureSize) {
++ qWarning("System maximum texture size is %d. This is lower than the value in '%s', which is %d",
++ systemMaxTextureSize,
++ qPrintable(font.familyName()),
++ m_maxTextureSize);
++ }
++
++ if (padding != QSG_RHI_DISTANCEFIELD_GLYPH_CACHE_PADDING) {
++ qWarning("Padding mismatch in '%s'. Font requires %d, but Qt is compiled with %d.",
++ qPrintable(font.familyName()),
++ padding,
++ QSG_RHI_DISTANCEFIELD_GLYPH_CACHE_PADDING);
++ }
++
++ m_referenceFont.setPixelSize(pixelSize);
++
++ quint32 glyphCount = Qtdf::fetch<quint32>(qtdfTableStart, Qtdf::numGlyphs);
++ m_unusedGlyphs.reserve(glyphCount);
++
++ const char *allocatorData = qtdfTableStart + Qtdf::HeaderSize;
++ {
++ m_areaAllocator = new QSGAreaAllocator(QSize(0, 0), m_maxTextureSize);
++ allocatorData = m_areaAllocator->deserialize(allocatorData, qtdfTableEnd - allocatorData);
++ if (allocatorData == nullptr)
++ return false;
++ }
++
++ if (m_areaAllocator->size().height() % m_maxTextureSize != 0) {
++ qWarning("Area allocator size mismatch in '%s'", qPrintable(font.familyName()));
++ return false;
++ }
++
++ textureCount = m_areaAllocator->size().height() / m_maxTextureSize;
++ m_maxTextureCount = qMax(m_maxTextureCount, textureCount);
++
++ const char *textureRecord = allocatorData;
++ for (int i = 0; i < textureCount; ++i, textureRecord += Qtdf::TextureRecordSize) {
++ if (qtdfTableEnd - textureRecord < Qtdf::TextureRecordSize) {
++ qWarning("qtdf table too small in font '%s'.",
++ qPrintable(font.familyName()));
++ return false;
++ }
++
++ TextureInfo *tex = textureInfo(i);
++ // Stored as quint32 in the table, but QRect uses int.
++ const quint32 allocX = Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedX);
++ const quint32 allocY = Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedY);
++ const quint32 allocWidth = Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedWidth);
++ const quint32 allocHeight = Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedHeight);
++ const quint32 maxSize = quint32(m_maxTextureSize);
++ // maxSize is the slice height of the area allocator, and a glyph that crosses a slice
++ // boundary expands the texture it is assigned to past the slice, by up to one glyph
++ // height - and a glyph can be no taller than the slice itself. The
++ // tallest valid texture is therefore 2 * maxSize - 1.
++ const quint32 maxTexHeight = maxSize * 2 - 1;
++ if (allocX > maxSize || allocY > maxSize
++ || allocWidth > maxSize || allocHeight > maxTexHeight) {
++ qWarning("Invalid texture geometry in qtdf table in font '%s'",
++ qPrintable(font.familyName()));
++ return false;
++ }
++
++ tex->allocatedArea.setX(int(allocX));
++ tex->allocatedArea.setY(int(allocY));
++ tex->allocatedArea.setWidth(int(allocWidth));
++ tex->allocatedArea.setHeight(int(allocHeight));
++ tex->padding = Qtdf::fetch<quint8>(textureRecord, Qtdf::texturePadding);
++ }
++
++ const char *glyphRecord = textureRecord;
++ for (quint32 i = 0; i < glyphCount; ++i, glyphRecord += Qtdf::GlyphRecordSize) {
++ if (qtdfTableEnd - glyphRecord < Qtdf:: GlyphRecordSize) {
++ qWarning("qtdf table too small in font '%s'.",
++ qPrintable(font.familyName()));
++ return false;
++ }
++
++ glyph_t glyph = Qtdf::fetch<quint32>(glyphRecord, Qtdf::glyphIndex);
++ m_unusedGlyphs.insert(glyph);
++
++ GlyphData &glyphData = emptyData(glyph);
++
++ #define FROM_FIXED_POINT(value) \
++ (((qreal)value)/(qreal)65536)
++
++ glyphData.texCoord.x = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureOffsetX));
++ glyphData.texCoord.y = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureOffsetY));
++ glyphData.texCoord.width = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureWidth));
++ glyphData.texCoord.height = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureHeight));
++ glyphData.texCoord.xMargin = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::xMargin));
++ glyphData.texCoord.yMargin = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::yMargin));
++ glyphData.boundingRect.setX(FROM_FIXED_POINT(Qtdf::fetch<qint32>(glyphRecord, Qtdf::boundingRectX)));
++ glyphData.boundingRect.setY(FROM_FIXED_POINT(Qtdf::fetch<qint32>(glyphRecord, Qtdf::boundingRectY)));
++ glyphData.boundingRect.setWidth(FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::boundingRectWidth)));
++ glyphData.boundingRect.setHeight(FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::boundingRectHeight)));
++
++ #undef FROM_FIXED_POINT
++
++ int textureIndex = Qtdf::fetch<quint16>(glyphRecord, Qtdf::textureIndex);
++ if (textureIndex < 0 || textureIndex >= textureCount) {
++ qWarning("Invalid texture index %d (texture count == %d) in '%s'",
++ textureIndex,
++ textureCount,
++ qPrintable(font.familyName()));
++ return false;
++ }
++
++
++ TextureInfo *texInfo = textureInfo(textureIndex);
++ m_glyphsTexture.insert(glyph, texInfo);
++
++ glyphTextures[texInfo].append(glyph);
++ }
++
++ const uchar *textureData = reinterpret_cast<const uchar *>(glyphRecord);
++ for (int i = 0; i < textureCount; ++i) {
++
++ TextureInfo *texInfo = textureInfo(i);
++
++ int width = texInfo->allocatedArea.width();
++ int height = texInfo->allocatedArea.height();
++ if (width <= 0 || height <= 0) {
++ qWarning("Invalid texture size in qtdf table in font '%s'",
++ qPrintable(font.familyName()));
++ return false;
++ }
++ qint64 size = qint64(width) * height;
++ if (qtdfTableEnd - reinterpret_cast<const char *>(textureData) < size) {
++ qWarning("qtdf table too small in font '%s'.",
++ qPrintable(font.familyName()));
++ return false;
++ }
++
++ createTexture(texInfo, width, height, textureData);
++ textureData += size;
++
++ if (!texInfo->texture)
++ continue;
++
++ QList<glyph_t> glyphs = glyphTextures.value(texInfo);
++
++ Texture t;
++ t.texture = texInfo->texture;
++ t.size = texInfo->size;
++
++ setGlyphsTexture(glyphs, t);
++ }
++ }
++
++ if (profile) {
++ quint64 now = timer.elapsed();
++ qCDebug(QSG_LOG_TIME_GLYPH,
++ "distancefield: %d pre-generated glyphs loaded in %dms",
++ int(m_unusedGlyphs.size()),
++ int(now));
++ }
++
++ return true;
++ }
++
++ void QSGRhiDistanceFieldGlyphCache::commitResourceUpdates(QRhiResourceUpdateBatch *mergeInto)
++ {
++ if (QRhiResourceUpdateBatch *resourceUpdates = m_rc->maybeGlyphCacheResourceUpdates()) {
++ mergeInto->merge(resourceUpdates);
++ m_rc->resetGlyphCacheResources();
++ }
++ }
++
++ bool QSGRhiDistanceFieldGlyphCache::eightBitFormatIsAlphaSwizzled() const
++ {
++ // return true when the shaders for 8-bit formats need .a instead of .r
++ // when sampling the texture
++ return !m_rhi->isFeatureSupported(QRhi::RedOrAlpha8IsRed);
++ }
++
++ bool QSGRhiDistanceFieldGlyphCache::screenSpaceDerivativesSupported() const
++ {
++ return m_rhi->isFeatureSupported(QRhi::ScreenSpaceDerivatives);
++ }
++
++ #if defined(QSG_DISTANCEFIELD_CACHE_DEBUG)
++ void QSGRhiDistanceFieldGlyphCache::saveTexture(QRhiTexture *texture, const QString &nameBase) const
++ {
++ quint64 textureId = texture->nativeTexture().object;
++ QString fileName = nameBase + QLatin1Char('_') + QString::number(textureId, 16);
++ fileName.replace(QLatin1Char('/'), QLatin1Char('_'));
++ fileName.replace(QLatin1Char(' '), QLatin1Char('_'));
++ fileName.append(QLatin1String(".png"));
++
++ QRhiReadbackResult *rbResult = new QRhiReadbackResult;
++ rbResult->completed = [rbResult, fileName] {
++ const QSize size = rbResult->pixelSize;
++ const qint64 numPixels = qint64(size.width()) * size.height();
++ if (numPixels == rbResult->data.size()) {
++ // 1 bpp data, may be packed; copy it to ensure QImage scanline alignment
++ QImage image(size, QImage::Format_Grayscale8);
++ const char *p = rbResult->data.constData();
++ for (int i = 0; i < size.height(); i++)
++ memcpy(image.scanLine(i), p + (i * size.width()), size.width());
++ image.save(fileName);
++ } else if (4 * numPixels == rbResult->data.size()) {
++ // 4 bpp data
++ const uchar *p = reinterpret_cast<const uchar *>(rbResult->data.constData());
++ QImage image(p, size.width(), size.height(), QImage::Format_RGBA8888);
++ image.save(fileName);
++ } else {
++ qWarning("Unhandled data format in glyph texture");
++ }
++ delete rbResult;
++ };
++
++ QRhiReadbackDescription rb(texture);
++ QRhiResourceUpdateBatch *resourceUpdates = m_rc->glyphCacheResourceUpdates();
++ resourceUpdates->readBackTexture(rb, rbResult);
++ }
++ #endif
++
++ QT_END_NAMESPACE