1// Copyright (C) 2019 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qsgrhitextureglyphcache_p.h"
5#include "qsgdefaultrendercontext_p.h"
6#include <qrgb.h>
7#include <private/qdrawhelper_p.h>
8
9QT_BEGIN_NAMESPACE
10
11QSGRhiTextureGlyphCache::QSGRhiTextureGlyphCache(QSGDefaultRenderContext *rc,
12 QFontEngine::GlyphFormat format, const QTransform &matrix,
13 const QColor &color)
14 : QImageTextureGlyphCache(format, matrix, color),
15 m_rc(rc),
16 m_rhi(rc->rhi())
17{
18 // Some OpenGL implementations, for instance macOS, have issues with
19 // GL_ALPHA render targets. Similarly, BGRA may be problematic on GLES 2.0.
20 // So stick with plain image uploads on GL.
21 m_resizeWithTextureCopy = m_rhi->backend() != QRhi::OpenGLES2;
22}
23
24QSGRhiTextureGlyphCache::~QSGRhiTextureGlyphCache()
25{
26 m_rc->deferredReleaseGlyphCacheTexture(texture: m_texture);
27}
28
29QRhiTexture *QSGRhiTextureGlyphCache::createEmptyTexture(QRhiTexture::Format format)
30{
31 QRhiTexture *t = m_rhi->newTexture(format, pixelSize: m_size, sampleCount: 1, flags: QRhiTexture::UsedAsTransferSource);
32 if (!t->create()) {
33 qWarning(msg: "Failed to build new glyph cache texture of size %dx%d", m_size.width(), m_size.height());
34 return nullptr;
35 }
36
37 QRhiResourceUpdateBatch *resourceUpdates = m_rc->glyphCacheResourceUpdates();
38
39 // The new texture must be cleared to 0 always, this cannot be avoided
40 // otherwise artifacts will occur around the glyphs.
41 QByteArray data;
42 if (format == QRhiTexture::RED_OR_ALPHA8)
43 data.fill(c: 0, size: m_size.width() * m_size.height());
44 else
45 data.fill(c: 0, size: m_size.width() * m_size.height() * 4);
46 QRhiTextureSubresourceUploadDescription subresDesc(data.constData(), data.size());
47 subresDesc.setSourceSize(m_size);
48 resourceUpdates->uploadTexture(tex: t, desc: QRhiTextureUploadEntry(0, 0, subresDesc));
49
50 return t;
51}
52
53void QSGRhiTextureGlyphCache::createTextureData(int width, int height)
54{
55 width = qMax(a: 128, b: width);
56 height = qMax(a: 32, b: height);
57
58 if (!m_resizeWithTextureCopy)
59 QImageTextureGlyphCache::createTextureData(width, height);
60
61 m_size = QSize(width, height);
62}
63
64void QSGRhiTextureGlyphCache::resizeTextureData(int width, int height)
65{
66 width = qMax(a: 128, b: width);
67 height = qMax(a: 32, b: height);
68
69 if (m_size.width() >= width && m_size.height() >= height)
70 return;
71
72 m_size = QSize(width, height);
73
74 if (m_texture) {
75 QRhiTexture *t = createEmptyTexture(format: m_texture->format());
76 if (!t)
77 return;
78
79 QRhiResourceUpdateBatch *resourceUpdates = m_rc->glyphCacheResourceUpdates();
80 if (m_resizeWithTextureCopy) {
81 resourceUpdates->copyTexture(dst: t, src: m_texture);
82 } else {
83 QImageTextureGlyphCache::resizeTextureData(width, height);
84 QImage img = image();
85 prepareGlyphImage(img: &img);
86 QRhiTextureSubresourceUploadDescription subresDesc(img);
87 const QSize oldSize = m_texture->pixelSize();
88 subresDesc.setSourceSize(QSize(qMin(a: oldSize.width(), b: width), qMin(a: oldSize.height(), b: height)));
89 resourceUpdates->uploadTexture(tex: t, desc: QRhiTextureUploadEntry(0, 0, subresDesc));
90 }
91
92 m_rc->deferredReleaseGlyphCacheTexture(texture: m_texture);
93 m_texture = t;
94 }
95}
96
97void QSGRhiTextureGlyphCache::beginFillTexture()
98{
99 Q_ASSERT(m_uploads.isEmpty());
100}
101
102void QSGRhiTextureGlyphCache::prepareGlyphImage(QImage *img)
103{
104 const int maskWidth = img->width();
105 const int maskHeight = img->height();
106#if Q_BYTE_ORDER != Q_BIG_ENDIAN
107 const bool supportsBgra = m_rhi->isTextureFormatSupported(format: QRhiTexture::BGRA8);
108#endif
109 m_bgra = false;
110
111 if (img->format() == QImage::Format_Mono) {
112 *img = img->convertToFormat(f: QImage::Format_Grayscale8);
113 } else if (img->depth() == 32) {
114 if (img->format() == QImage::Format_RGB32 || img->format() == QImage::Format_ARGB32_Premultiplied) {
115 // We need to make the alpha component equal to the average of the RGB values.
116 // This is needed when drawing sub-pixel antialiased text on translucent targets.
117 for (int y = 0; y < maskHeight; ++y) {
118 QRgb *src = (QRgb *) img->scanLine(y);
119 for (int x = 0; x < maskWidth; ++x) {
120 int r = qRed(rgb: src[x]);
121 int g = qGreen(rgb: src[x]);
122 int b = qBlue(rgb: src[x]);
123 int avg;
124 if (img->format() == QImage::Format_RGB32)
125 avg = (r + g + b + 1) / 3; // "+1" for rounding.
126 else // Format_ARGB_Premultiplied
127 avg = qAlpha(rgb: src[x]);
128
129 src[x] = qRgba(r, g, b, a: avg);
130#if Q_BYTE_ORDER != Q_BIG_ENDIAN
131 if (supportsBgra) {
132 m_bgra = true;
133 } else {
134 // swizzle the bits to accommodate for the RGBA upload.
135 src[x] = ARGB2RGBA(x: src[x]);
136 m_bgra = false;
137 }
138#endif
139 }
140 }
141 }
142 }
143}
144
145void QSGRhiTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph, const QFixedPoint &subPixelPosition)
146{
147 QRhiTextureSubresourceUploadDescription subresDesc;
148 QImage mask;
149
150 if (!m_resizeWithTextureCopy) {
151 QImageTextureGlyphCache::fillTexture(c, glyph, subPixelPosition);
152 mask = image();
153 subresDesc.setSourceTopLeft(QPoint(c.x, c.y));
154 subresDesc.setSourceSize(QSize(c.w, c.h));
155 } else {
156 mask = textureMapForGlyph(g: glyph, subPixelPosition);
157 }
158
159 prepareGlyphImage(img: &mask);
160
161 subresDesc.setImage(mask);
162 subresDesc.setDestinationTopLeft(QPoint(c.x, c.y));
163 m_uploads.append(t: QRhiTextureUploadEntry(0, 0, subresDesc));
164}
165
166void QSGRhiTextureGlyphCache::endFillTexture()
167{
168 if (m_uploads.isEmpty())
169 return;
170
171 if (!m_texture) {
172 QRhiTexture::Format texFormat;
173 if (m_format == QFontEngine::Format_A32 || m_format == QFontEngine::Format_ARGB)
174 texFormat = m_bgra ? QRhiTexture::BGRA8 : QRhiTexture::RGBA8;
175 else // should be R8, but there is the OpenGL ES 2.0 nonsense
176 texFormat = QRhiTexture::RED_OR_ALPHA8;
177
178 m_texture = createEmptyTexture(format: texFormat);
179 if (!m_texture)
180 return;
181 }
182
183 QRhiResourceUpdateBatch *resourceUpdates = m_rc->glyphCacheResourceUpdates();
184 QRhiTextureUploadDescription desc;
185 desc.setEntries(first: m_uploads.cbegin(), last: m_uploads.cend());
186 resourceUpdates->uploadTexture(tex: m_texture, desc);
187 m_uploads.clear();
188}
189
190int QSGRhiTextureGlyphCache::glyphPadding() const
191{
192 if (m_format == QFontEngine::Format_Mono)
193 return 8;
194 else
195 return 1;
196}
197
198int QSGRhiTextureGlyphCache::maxTextureWidth() const
199{
200 return m_rhi->resourceLimit(limit: QRhi::TextureSizeMax);
201}
202
203int QSGRhiTextureGlyphCache::maxTextureHeight() const
204{
205 if (!m_resizeWithTextureCopy)
206 return qMin(a: 1024, b: m_rhi->resourceLimit(limit: QRhi::TextureSizeMax));
207
208 return m_rhi->resourceLimit(limit: QRhi::TextureSizeMax);
209}
210
211void QSGRhiTextureGlyphCache::commitResourceUpdates(QRhiResourceUpdateBatch *mergeInto)
212{
213 if (QRhiResourceUpdateBatch *resourceUpdates = m_rc->maybeGlyphCacheResourceUpdates()) {
214 mergeInto->merge(other: resourceUpdates);
215 m_rc->resetGlyphCacheResources();
216 }
217}
218
219bool QSGRhiTextureGlyphCache::eightBitFormatIsAlphaSwizzled() const
220{
221 // return true when the shaders for 8-bit formats need .a instead of .r
222 // when sampling the texture
223 return !m_rhi->isFeatureSupported(feature: QRhi::RedOrAlpha8IsRed);
224}
225
226QT_END_NAMESPACE
227

source code of qtdeclarative/src/quick/scenegraph/qsgrhitextureglyphcache.cpp