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