Add distance field rendering to OpenGL runtime

The old text rendering remains in the background and is used to render
clipped text, since that feature is not yet implemented for distance
field fonts. Building the runtime with Qt version older than 5.12.2 also
causes a fallback to the old text rendering.

Depth pass rendering also needs to be redone in the future to avoid
another full render pass.

Task-number: QT3DS-3210
Change-Id: Ib7666c437d23ae25e1872682f010df3721476a14
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>

1 files changed, 519 insertions, 0 deletions

diff --git a/src/Runtime/Source/runtimerender/Qt3DSDistanceFieldGlyphCache.cpp b/src/Runtime/Source/runtimerender/Qt3DSDistanceFieldGlyphCache.cpp
new file mode 100644
index 00000000..c6941860
--- /dev/null
+++ b/src/Runtime/Source/runtimerender/Qt3DSDistanceFieldGlyphCache.cpp
@@ -0,0 +1,519 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of Qt 3D Studio.
+**
+** $QT_BEGIN_LICENSE:GPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) any later version
+** approved by the KDE Free Qt Foundation. The licenses are as published by
+** the Free Software Foundation and appearing in the file LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "Qt3DSDistanceFieldGlyphCache_p.h"
+
+#include <QtQuick/private/qsgareaallocator_p.h>
+
+#include <QtCore/qmath.h>
+#include <QtCore/qendian.h>
+#include <QtGui/qimage.h>
+
+#include "render/Qt3DSRenderContext.h"
+#include "render/Qt3DSRenderBaseTypes.h"
+#include "Qt3DSRenderResourceManager.h"
+#include "foundation/Qt3DSAllocator.h"
+
+#if QT_VERSION >= QT_VERSION_CHECK(5,12,2)
+
+QT_BEGIN_NAMESPACE
+
+// Should work on most hardware. Used as stop gap until Qt 3D provides a
+// way to retrieve the system value
+#ifndef Q3DSDISTANCEFIELDGLYPHCACHE_MAXIMUM_TEXURE_SIZE
+#  define Q3DSDISTANCEFIELDGLYPHCACHE_MAXIMUM_TEXURE_SIZE 2048
+#endif
+
+#if !defined(Q3DSDISTANCEFIELDGLYPHCACHE_PADDING)
+#  define Q3DSDISTANCEFIELDGLYPHCACHE_PADDING 2
+#endif
+
+Q3DSDistanceFieldGlyphCache::Q3DSDistanceFieldGlyphCache(
+        const QRawFont &font, qt3ds::render::IQt3DSRenderContext &context)
+    : QSGDistanceFieldGlyphCache(font)
+    , m_context(context)
+{
+    m_maxTextureSize = Q3DSDISTANCEFIELDGLYPHCACHE_MAXIMUM_TEXURE_SIZE;
+
+    loadPregeneratedCache(font);
+}
+
+Q3DSDistanceFieldGlyphCache::~Q3DSDistanceFieldGlyphCache()
+{
+    for (auto &texture : m_textures)
+        qt3ds::foundation::NVDelete(m_context.GetAllocator(), texture.texture);
+}
+
+int Q3DSDistanceFieldGlyphCache::maxTextureSize() const
+{
+    return m_maxTextureSize;
+}
+
+Q3DSDistanceFieldGlyphCache::TextureInfo *Q3DSDistanceFieldGlyphCache::textureInfo(int index) const
+{
+    while (index >= m_textures.size())
+        m_textures.append(TextureInfo());
+    return &m_textures[index];
+}
+
+void Q3DSDistanceFieldGlyphCache::referenceGlyphs(const QSet<glyph_t> &glyphs)
+{
+    m_unusedGlyphs -= glyphs;
+}
+
+void Q3DSDistanceFieldGlyphCache::releaseGlyphs(const QSet<glyph_t> &glyphs)
+{
+    m_unusedGlyphs += glyphs;
+}
+
+void Q3DSDistanceFieldGlyphCache::resizeTexture(TextureInfo *info, int width, int height)
+{
+    QImage &image = info->copy;
+    if (info->texture == nullptr) {
+        info->texture = m_context.GetRenderContext().CreateTexture2D();
+        info->texture->SetMinFilter(qt3ds::render::NVRenderTextureMinifyingOp::Enum::Linear);
+        info->texture->SetMagFilter(qt3ds::render::NVRenderTextureMagnifyingOp::Enum::Linear);
+        info->texture->SetTextureData(qt3ds::render::toU8DataRef(image.bits(), image.byteCount()),
+                                      0, image.width(), image.height(),
+                                      qt3ds::render::NVRenderTextureFormats::R8);
+    }
+
+    qt3ds::render::STextureDetails textureDetails = info->texture->GetTextureDetails();
+    if (int(textureDetails.m_Width) != width || int(textureDetails.m_Height) != height) {
+        info->texture->SetTextureData(qt3ds::render::toU8DataRef(image.bits(), image.byteCount()),
+                                      0, image.width(), image.height(),
+                                      qt3ds::render::NVRenderTextureFormats::R8);
+    }
+
+    if (info->copy.width() != width || info->copy.height() != height) {
+        QImage newImage(width, height, QImage::Format_Alpha8);
+
+        for (int y = 0; y < info->copy.height(); ++y) {
+            uchar *dest = newImage.scanLine(y);
+            const uchar *src = info->copy.scanLine(y);
+            ::memcpy(dest, src, size_t(info->copy.width()));
+        }
+
+        info->copy = newImage;
+
+        info->texture->SetTextureData(qt3ds::render::toU8DataRef(image.bits(), image.byteCount()),
+                                      0, image.width(), image.height(),
+                                      qt3ds::render::NVRenderTextureFormats::R8);
+    }
+}
+
+void Q3DSDistanceFieldGlyphCache::storeGlyphs(const QList<QDistanceField> &glyphs)
+{
+    using GlyphTextureHash = QHash<TextureInfo *, QVector<glyph_t> >;
+    using GlyphTextureHashConstIt = GlyphTextureHash::const_iterator;
+
+    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, maxTextureSize(), texInfo->allocatedArea.height());
+
+        Q_ASSERT(!glyphTextures[texInfo].contains(glyphIndex));
+        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);
+
+        for (int y = 0; y < glyph.height(); ++y) {
+            const uchar *src = glyph.scanLine(y);
+            uchar *dest = texInfo->copy.scanLine(int(c.y) + y - padding) + (int(c.x) - padding);
+            ::memcpy(dest, src, size_t(glyph.width()));
+        }
+    }
+
+    for (GlyphTextureHashConstIt i = glyphTextures.constBegin(),
+         cend = glyphTextures.constEnd(); i != cend; ++i) {
+        Texture t;
+         // 0 == empty texture, (i - 1) == index into m_textures
+        t.textureId = uint(i.key() - m_textures.constData()) + 1;
+        qt3ds::render::STextureDetails textureDetails = i.key()->texture->GetTextureDetails();
+        t.size = QSize(textureDetails.m_Width, textureDetails.m_Height);
+        setGlyphsTexture(i.value(), t);
+
+        QImage &image = i.key()->copy;
+
+        i.key()->texture->SetTextureData(qt3ds::render::toU8DataRef(image.bits(),
+                                                                    image.byteCount()),
+                                         0, image.width(), image.height(),
+                                         qt3ds::render::NVRenderTextureFormats::R8);
+    }
+}
+
+void Q3DSDistanceFieldGlyphCache::requestGlyphs(const QSet<glyph_t> &glyphs)
+{
+    // Note: Most of this is copy-pasted from QSGDefaultDistanceFieldGlyphCache in Qt Quick.
+    // All of this can probably be shared as a default implementation, since it does not
+    // actually create any textures, but it might have to be either templated or based
+    // on void*. For now we will just live with the duplication.
+
+    QList<GlyphPosition> glyphPositions;
+    QVector<glyph_t> glyphsToRender;
+
+    if (m_areaAllocator == nullptr) {
+        m_areaAllocator = new QSGAreaAllocator(QSize(maxTextureSize(),
+                                                     m_maxTextureCount * maxTextureSize()));
+    }
+
+    for (QSet<glyph_t>::const_iterator it = glyphs.constBegin(); it != glyphs.constEnd() ; ++it) {
+        glyph_t glyphIndex = *it;
+
+        int padding = Q3DSDISTANCEFIELDGLYPHCACHE_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);
+                QRectF unusedGlyphBoundingRect = glyphData(unusedGlyph).boundingRect;
+                int unusedGlyphWidth = qCeil(unusedGlyphBoundingRect.width())
+                        + distanceFieldRadius() * 2;
+                int unusedGlyphHeight = qCeil(unusedGlyphBoundingRect.height())
+                        + distanceFieldRadius() * 2;
+                m_areaAllocator->deallocate(QRect(int(unusedCoord.x) - padding,
+                                                  int(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());
+
+        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);
+}
+
+void Q3DSDistanceFieldGlyphCache::processPendingGlyphs()
+{
+    update();
+}
+
+Q3DSDistanceFieldGlyphCache::TextureInfo *Q3DSDistanceFieldGlyphCache::textureInfoById(
+        uint id) const
+{
+    Q_ASSERT(id > 0);
+    return textureInfo(id - 1);
+}
+
+// This is all copy-pasted from Qt Quick, as sharing it would require some refactoring, and we
+// need to work with Qt 5.12.2 at the moment.
+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));
+        }
+    };
+}
+
+qreal Q3DSDistanceFieldGlyphCache::fontSize() const
+{
+    return QT_DISTANCEFIELD_BASEFONTSIZE(m_doubleGlyphResolution);
+}
+
+bool Q3DSDistanceFieldGlyphCache::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;
+    }
+
+    QByteArray qtdfTable = font.fontTable("qtdf");
+    if (qtdfTable.isEmpty())
+        return false;
+
+    using GlyphTextureHash = QHash<TextureInfo *, QVector<glyph_t> >;
+
+    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 = int(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;
+        }
+
+        if (padding != Q3DSDISTANCEFIELDGLYPHCACHE_PADDING) {
+            qWarning("Padding mismatch in '%s'. Font requires %d, but Qt is compiled with %d.",
+                     qPrintable(font.familyName()),
+                     padding,
+                     Q3DSDISTANCEFIELDGLYPHCACHE_PADDING);
+        }
+
+        m_referenceFont.setPixelSize(pixelSize);
+
+        quint32 glyphCount = Qtdf::fetch<quint32>(qtdfTableStart, Qtdf::numGlyphs);
+        m_unusedGlyphs.reserve(int(glyphCount));
+
+        const char *allocatorData = qtdfTableStart + Qtdf::HeaderSize;
+        {
+            m_areaAllocator = new QSGAreaAllocator(QSize(0, 0));
+            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 (textureRecord + Qtdf::TextureRecordSize > qtdfTableEnd) {
+                qWarning("qtdf table too small in font '%s'.",
+                         qPrintable(font.familyName()));
+                return false;
+            }
+
+            TextureInfo *tex = textureInfo(i);
+            tex->allocatedArea.setX(int(Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedX)));
+            tex->allocatedArea.setY(int(Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedY)));
+            tex->allocatedArea.setWidth(int(Qtdf::fetch<quint32>(textureRecord,
+                                                                 Qtdf::allocatedWidth)));
+            tex->allocatedArea.setHeight(int(Qtdf::fetch<quint32>(textureRecord,
+                                                                  Qtdf::allocatedHeight)));
+            tex->padding = Qtdf::fetch<quint8>(textureRecord, Qtdf::texturePadding);
+        }
+
+        const char *glyphRecord = textureRecord;
+        for (quint32 i = 0; i < glyphCount; ++i, glyphRecord += Qtdf::GlyphRecordSize) {
+            if (glyphRecord + Qtdf::GlyphRecordSize > qtdfTableEnd) {
+                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();
+            qint64 size = width * height;
+            if (reinterpret_cast<const char *>(textureData + size) > qtdfTableEnd) {
+                qWarning("qtdf table too small in font '%s'.",
+                         qPrintable(font.familyName()));
+                return false;
+            }
+
+            resizeTexture(texInfo, width, height);
+
+            memcpy(texInfo->copy.bits(), textureData, size);
+            textureData += size;
+
+            QImage &image = texInfo->copy;
+            texInfo->texture->SetTextureData(qt3ds::render::toU8DataRef(image.bits(),
+                                                                        image.byteCount()),
+                                             0, image.width(), image.height(),
+                                             qt3ds::render::NVRenderTextureFormats::R8);
+
+            QVector<glyph_t> glyphs = glyphTextures.value(texInfo);
+
+            Texture t;
+            t.textureId = uint(i + 1);
+            t.size = texInfo->copy.size();
+
+            setGlyphsTexture(glyphs, t);
+        }
+    }
+
+    return true;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_VERSION >= QT_VERSION_CHECK(5,12,2)