Revision control
++ // Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB).
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qtext2dentity.h"
++ #include "qtext2dentity_p.h"
++ #include "qtext2dmaterial_p.h"
++
++ #include <QtGui/qtextlayout.h>
++ #include <QtGui/qglyphrun.h>
++ #include <QtGui/private/qdistancefield_p.h>
++ #include <QtGui/private/qtextureglyphcache_p.h>
++ #include <QtGui/private/qfont_p.h>
++ #include <QtGui/private/qdistancefield_p.h>
++
++ #include <Qt3DCore/qbuffer.h>
++ #include <Qt3DCore/qattribute.h>
++ #include <Qt3DCore/qgeometry.h>
++ #include <Qt3DRender/qmaterial.h>
++ #include <Qt3DRender/qgeometryrenderer.h>
++
++ #include <Qt3DCore/private/qscene_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace {
++
++ inline constexpr QRectF scaleRectF(const QRectF &rect, qreal scale)
++ {
++ return QRectF(rect.left() * scale, rect.top() * scale, rect.width() * scale, rect.height() * scale);
++ }
++
++ } // anonymous
++
++ namespace Qt3DExtras {
++
++ /*!
++ * \qmltype Text2DEntity
++ * \nativetype Qt3DExtras::QText2DEntity
++ * \inqmlmodule Qt3D.Extras
++ * \brief Text2DEntity allows creation of a 2D text in 3D space.
++ *
++ * The Text2DEntity renders text as triangles in the XY plane. The geometry will be fitted
++ * in the rectangle of specified width and height. If the resulting geometry is wider than
++ * the specified width, the remainder will be rendered on the new line.
++ *
++ * The entity can be positionned in the scene by adding a transform component.
++ *
++ * Text2DEntity will create geometry based on the shape of the glyphs and a solid
++ * material using the specified color.
++ *
++ */
++
++ /*!
++ * \qmlproperty string Text2DEntity::text
++ *
++ * Holds the text used for the mesh.
++ */
++
++ /*!
++ * \qmlproperty font Text2DEntity::font
++ *
++ * Holds the font of the text.
++ */
++
++ /*!
++ * \qmlproperty color Text2DEntity::color
++ *
++ * Holds the color of the text.
++ */
++
++ /*!
++ * \qmlproperty real Text2DEntity::width
++ *
++ * Holds the width of the text's bounding rectangle.
++ */
++
++ /*!
++ * \qmlproperty real Text2DEntity::height
++ *
++ * Holds the height of the text's bounding rectangle.
++ */
++
++ /*!
++ * \qmlproperty Qt::Alignment Text2DEntity::alignment
++ *
++ * Holds the alignment of the text.
++ */
++
++
++ /*!
++ * \class Qt3DExtras::QText2DEntity
++ * \inheaderfile Qt3DExtras/QText2DEntity
++ * \inmodule Qt3DExtras
++ *
++ * \brief QText2DEntity allows creation of a 2D text in 3D space.
++ *
++ * The QText2DEntity renders text as triangles in the XY plane. The geometry will be fitted
++ * in the rectangle of specified width and height. If the resulting geometry is wider than
++ * the specified width, the remainder will be rendered on the new line.
++ *
++ * The entity can be positionned in the scene by adding a transform component.
++ *
++ * QText2DEntity will create geometry based on the shape of the glyphs and a solid
++ * material using the specified color.
++ *
++ */
++
++ QHash<Qt3DCore::QScene *, QText2DEntityPrivate::CacheEntry> QText2DEntityPrivate::m_glyphCacheInstances;
++
++ QText2DEntityPrivate::QText2DEntityPrivate()
++ : m_glyphCache(nullptr)
++ , m_font(QLatin1String("Times"), 10)
++ , m_scaledFont(QLatin1String("Times"), 10)
++ , m_color(QColor(255, 255, 255, 255))
++ , m_width(0.0f)
++ , m_height(0.0f)
++ , m_alignment(Qt::AlignTop | Qt::AlignLeft)
++ {
++ }
++
++ QText2DEntityPrivate::~QText2DEntityPrivate()
++ {
++ }
++
++ void QText2DEntityPrivate::setScene(Qt3DCore::QScene *scene)
++ {
++ if (scene == m_scene)
++ return;
++
++ // Unref old glyph cache if it exists
++ if (m_scene != nullptr) {
++ // Ensure we don't keep reference to glyphs
++ // if we are changing the cache
++ if (m_glyphCache != nullptr)
++ clearCurrentGlyphRuns();
++
++ m_glyphCache = nullptr;
++
++ QText2DEntityPrivate::CacheEntry &entry = QText2DEntityPrivate::m_glyphCacheInstances[m_scene];
++ --entry.count;
++ if (entry.count == 0 && entry.glyphCache != nullptr) {
++
++ delete entry.glyphCache;
++ entry.glyphCache = nullptr;
++ }
++ }
++
++ QEntityPrivate::setScene(scene);
++
++ // Ref new glyph cache is scene is valid
++ if (scene != nullptr) {
++ QText2DEntityPrivate::CacheEntry &entry = QText2DEntityPrivate::m_glyphCacheInstances[scene];
++ if (entry.glyphCache == nullptr) {
++ entry.glyphCache = new QDistanceFieldGlyphCache();
++ entry.glyphCache->setRootNode(scene->rootNode());
++ }
++ m_glyphCache = entry.glyphCache;
++ ++entry.count;
++ // Update to populate glyphCache if needed
++ updateGlyphs();
++ }
++ }
++
++ QText2DEntity::QText2DEntity(QNode *parent)
++ : Qt3DCore::QEntity(*new QText2DEntityPrivate(), parent)
++ {
++ }
++
++ /*! \internal */
++ QText2DEntity::~QText2DEntity()
++ {
++ }
++
++ qreal QText2DEntityPrivate::computeActualScale() const
++ {
++ // scale font based on fontScale property and given QFont
++ float scale = 1.0f;
++ if (m_font.pointSizeF() > 0)
++ scale *= m_font.pointSizeF() / m_scaledFont.pointSizeF();
++ return scale;
++ }
++
++ struct RenderData {
++ int vertexCount = 0;
++ std::vector<float> vertex;
++ std::vector<quint16> index;
++ };
++
++ void QText2DEntityPrivate::setCurrentGlyphRuns(const QList<QGlyphRun> &runs)
++ {
++ // For each distinct texture, we need a separate DistanceFieldTextRenderer,
++ // for which we need vertex and index data
++ QHash<Qt3DRender::QAbstractTexture*, RenderData> renderData;
++ const qreal scale = computeActualScale();
++
++ // process glyph runs
++ for (const QGlyphRun &run : runs) {
++ const auto glyphs = run.glyphIndexes();
++ const auto pos = run.positions();
++
++ Q_ASSERT(glyphs.size() == pos.size());
++
++ const bool doubleGlyphResolution = m_glyphCache->doubleGlyphResolution(run.rawFont());
++
++ // faithfully copied from QSGDistanceFieldGlyphNode::updateGeometry()
++ const qreal pixelSize = run.rawFont().pixelSize();
++ const qreal fontScale = pixelSize / QT_DISTANCEFIELD_BASEFONTSIZE(doubleGlyphResolution);
++ const qreal margin = QT_DISTANCEFIELD_RADIUS(doubleGlyphResolution) / QT_DISTANCEFIELD_SCALE(doubleGlyphResolution) * fontScale;
++
++ for (int i = 0; i < glyphs.size(); i++) {
++ const QDistanceFieldGlyphCache::Glyph &dfield = m_glyphCache->refGlyph(run.rawFont(), glyphs[i]);
++
++ if (!dfield.texture)
++ continue;
++
++ RenderData &data = renderData[dfield.texture];
++
++ // faithfully copied from QSGDistanceFieldGlyphNode::updateGeometry()
++ QRectF metrics = scaleRectF(dfield.glyphPathBoundingRect, fontScale);
++ metrics.adjust(-margin, margin, margin, 3*margin);
++
++ const qreal top = 0.0;
++ const qreal left = 0.0;
++ const qreal right = qreal(m_width);
++ const qreal bottom = qreal(m_height);
++
++ qreal x1 = left + scale * (pos[i].x() + metrics.left());
++ qreal y2 = bottom - scale * (pos[i].y() - metrics.top());
++ qreal x2 = x1 + scale * metrics.width();
++ qreal y1 = y2 - scale * metrics.height();
++
++ // only draw glyphs that are at least partly visible
++ if (y2 < top || x1 > right)
++ continue;
++
++ QRectF texCoords = dfield.texCoords;
++
++ // if a glyph is only partly visible within the given rectangle,
++ // cut it in half and adjust tex coords
++ if (y1 < top) {
++ const auto insideRatio = (top - y2) / (y1 - y2);
++ y1 = top;
++ texCoords.setHeight(texCoords.height() * insideRatio);
++ }
++
++ // do the same thing horizontally
++ if (x2 > right) {
++ const auto insideRatio = (right - x1) / (x2 - x1);
++ x2 = right;
++ texCoords.setWidth(texCoords.width() * insideRatio);
++ }
++
++ for (auto v: std::vector<qreal>{x1, y1, qreal(i), texCoords.left(), texCoords.bottom()})
++ data.vertex.push_back(float(v));
++ for (auto v: std::vector<qreal>{x1, y2, qreal(i), texCoords.left(), texCoords.top()})
++ data.vertex.push_back(float(v));
++ for (auto v: std::vector<qreal>{x2, y1, qreal(i), texCoords.right(), texCoords.bottom()})
++ data.vertex.push_back(float(v));
++ for (auto v: std::vector<qreal>{x2, y2, qreal(i), texCoords.right(), texCoords.top()})
++ data.vertex.push_back(float(v));
++
++ for (int i: std::vector<int>{data.vertexCount, data.vertexCount + 3, data.vertexCount + 1})
++ data.index.push_back(quint16(i));
++ for (int i: std::vector<int>{data.vertexCount, data.vertexCount + 2, data.vertexCount + 3})
++ data.index.push_back(quint16(i));
++
++ data.vertexCount += 4;
++ }
++ }
++
++ // de-ref all glyphs for previous QGlyphRuns
++ for (int i = 0; i < m_currentGlyphRuns.size(); i++)
++ m_glyphCache->derefGlyphs(m_currentGlyphRuns[i]);
++ m_currentGlyphRuns = runs;
++
++ // make sure we have the correct number of DistanceFieldTextRenderers
++ // TODO: we might keep one renderer at all times, so we won't delete and
++ // re-allocate one every time the text changes from an empty to a non-empty string
++ // and vice-versa
++ while (m_renderers.size() > renderData.size())
++ delete m_renderers.takeLast();
++
++ while (m_renderers.size() < renderData.size()) {
++ DistanceFieldTextRenderer *renderer = new DistanceFieldTextRenderer();
++ renderer->setColor(m_color);
++ renderer->setParent(q_func());
++ m_renderers << renderer;
++ }
++
++ Q_ASSERT(m_renderers.size() == renderData.size());
++
++ // assign vertex data for all textures to the renderers
++ int rendererIdx = 0;
++ for (auto it = renderData.begin(); it != renderData.end(); ++it)
++ m_renderers[rendererIdx++]->setGlyphData(it.key(), it.value().vertex, it.value().index);
++ }
++
++ void QText2DEntityPrivate::clearCurrentGlyphRuns()
++ {
++ for (int i = 0; i < m_currentGlyphRuns.size(); i++)
++ m_glyphCache->derefGlyphs(m_currentGlyphRuns[i]);
++ m_currentGlyphRuns.clear();
++ }
++
++ void QText2DEntityPrivate::updateGlyphs()
++ {
++ if (m_glyphCache == nullptr)
++ return;
++
++ QList<QGlyphRun> glyphRuns;
++
++ // collect all GlyphRuns generated by the QTextLayout
++ if ((m_width > 0.0f || m_height > 0.0f) && !m_text.isEmpty()) {
++ QTextLayout layout(m_text, m_scaledFont);
++
++ QTextOption textOption = layout.textOption();
++ textOption.setAlignment(m_alignment);
++ layout.setTextOption(textOption);
++
++ const float lineWidth = m_width / computeActualScale();
++ float height = 0;
++ layout.beginLayout();
++
++ while (true) {
++ QTextLine line = layout.createLine();
++ if (!line.isValid())
++ break;
++
++ // position current line
++ line.setLineWidth(lineWidth);
++ line.setPosition(QPointF(0, height));
++ height += line.height();
++
++ // add glyph runs created by line
++ const QList<QGlyphRun> runs = line.glyphRuns();
++ for (const QGlyphRun &run : runs)
++ glyphRuns << run;
++ }
++
++ layout.endLayout();
++ }
++
++ setCurrentGlyphRuns(glyphRuns);
++ }
++
++ /*!
++ \property Qt3DExtras::QText2DEntity::font
++
++ Holds the font for the text item that is displayed
++ in the Qt Quick scene.
++ */
++ QFont QText2DEntity::font() const
++ {
++ Q_D(const QText2DEntity);
++ return d->m_font;
++ }
++
++ void QText2DEntity::setFont(const QFont &font)
++ {
++ Q_D(QText2DEntity);
++ if (d->m_font != font) {
++ // ignore the point size of the font, just make it a default value.
++ // still we want to make sure that font() returns the same value
++ // that was passed to setFont(), so we store it nevertheless
++ d->m_font = font;
++ d->m_scaledFont = font;
++ d->m_scaledFont.setPointSize(10);
++
++ emit fontChanged(font);
++
++ if (!d->m_text.isEmpty())
++ d->updateGlyphs();
++ }
++ }
++
++ /*!
++ \property Qt3DExtras::QText2DEntity::color
++
++ Holds the color for the text item that is displayed in the Qt
++ Quick scene.
++ */
++ QColor QText2DEntity::color() const
++ {
++ Q_D(const QText2DEntity);
++ return d->m_color;
++ }
++
++ void QText2DEntity::setColor(const QColor &color)
++ {
++ Q_D(QText2DEntity);
++ if (d->m_color != color) {
++ d->m_color = color;
++
++ emit colorChanged(color);
++
++ for (DistanceFieldTextRenderer *renderer : std::as_const(d->m_renderers))
++ renderer->setColor(color);
++ }
++ }
++
++ /*!
++ \property Qt3DExtras::QText2DEntity::text
++
++ Holds the text that is displayed in the Qt Quick scene.
++ */
++ QString QText2DEntity::text() const
++ {
++ Q_D(const QText2DEntity);
++ return d->m_text;
++ }
++
++ void QText2DEntity::setText(const QString &text)
++ {
++ Q_D(QText2DEntity);
++ if (d->m_text != text) {
++ d->m_text = text;
++ emit textChanged(text);
++
++ d->updateGlyphs();
++ }
++ }
++
++ /*!
++ \property Qt3DExtras::QText2DEntity::width
++
++ Returns the width of the text item that is displayed in the
++ Qt Quick scene.
++ */
++ float QText2DEntity::width() const
++ {
++ Q_D(const QText2DEntity);
++ return d->m_width;
++ }
++
++ /*!
++ \property Qt3DExtras::QText2DEntity::height
++
++ Returns the height of the text item that is displayed in the
++ Qt Quick scene.
++ */
++ float QText2DEntity::height() const
++ {
++ Q_D(const QText2DEntity);
++ return d->m_height;
++ }
++
++ void QText2DEntity::setWidth(float width)
++ {
++ Q_D(QText2DEntity);
++ if (width != d->m_width) {
++ d->m_width = width;
++ emit widthChanged(width);
++ d->updateGlyphs();
++ }
++ }
++
++ void QText2DEntity::setHeight(float height)
++ {
++ Q_D(QText2DEntity);
++ if (height != d->m_height) {
++ d->m_height = height;
++ emit heightChanged(height);
++ d->updateGlyphs();
++ }
++ }
++
++ /*!
++ \property Qt3DExtras::QText2DEntity::alignment
++
++ Returns the alignment of the text item that is displayed in the
++ Qt Quick scene.
++
++ The default alignment is top-left-aligned.
++ */
++ Qt::Alignment QText2DEntity::alignment() const
++ {
++ Q_D(const QText2DEntity);
++ return d->m_alignment;
++ }
++
++ void QText2DEntity::setAlignment(Qt::Alignment alignment)
++ {
++ Q_D(QText2DEntity);
++ if (alignment != d->m_alignment) {
++ d->m_alignment = alignment;
++ d->updateGlyphs();
++ }
++ }
++
++ } // namespace Qt3DExtras
++
++ QT_END_NAMESPACE
++
++ #include "moc_qtext2dentity.cpp"