1/****************************************************************************
2**
3** Copyright (C) 2018 The Qt Company Ltd.
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the QtQuick module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40#include "qsgopengldistancefieldglyphcache_p.h"
41
42#include <QtCore/qelapsedtimer.h>
43#include <QtCore/qbuffer.h>
44#include <QtCore/qendian.h>
45#include <QtQml/qqmlfile.h>
46
47#include <QtGui/private/qdistancefield_p.h>
48#include <QtGui/private/qopenglcontext_p.h>
49#include <QtQml/private/qqmlglobal_p.h>
50#include <qopenglfunctions.h>
51#include <qopenglframebufferobject.h>
52#include <qmath.h>
53#include "qsgcontext_p.h"
54
55
56#if !defined(QT_OPENGL_ES_2)
57#include <QtGui/qopenglfunctions_3_2_core.h>
58#endif
59
60QT_BEGIN_NAMESPACE
61
62DEFINE_BOOL_CONFIG_OPTION(qmlUseGlyphCacheWorkaround, QML_USE_GLYPHCACHE_WORKAROUND)
63DEFINE_BOOL_CONFIG_OPTION(qsgPreferFullSizeGlyphCacheTextures, QSG_PREFER_FULLSIZE_GLYPHCACHE_TEXTURES)
64
65#if !defined(QSG_OPENGL_DISTANCEFIELD_GLYPH_CACHE_PADDING)
66# define QSG_OPENGL_DISTANCEFIELD_GLYPH_CACHE_PADDING 2
67#endif
68
69QSGOpenGLDistanceFieldGlyphCache::QSGOpenGLDistanceFieldGlyphCache(QOpenGLContext *c,
70 const QRawFont &font)
71 : QSGDistanceFieldGlyphCache(font)
72 , m_maxTextureWidth(0)
73 , m_maxTextureHeight(0)
74 , m_maxTextureCount(3)
75 , m_areaAllocator(nullptr)
76 , m_blitProgram(nullptr)
77 , m_blitBuffer(QOpenGLBuffer::VertexBuffer)
78 , m_fboGuard(nullptr)
79 , m_funcs(c->functions())
80#if !defined(QT_OPENGL_ES_2)
81 , m_coreFuncs(nullptr)
82#endif
83{
84 if (Q_LIKELY(m_blitBuffer.create())) {
85 m_blitBuffer.bind();
86 static const GLfloat buffer[16] = {-1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f,
87 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f};
88 m_blitBuffer.allocate(buffer, sizeof(buffer));
89 m_blitBuffer.release();
90 } else {
91 qWarning("Buffer creation failed");
92 }
93
94 m_coreProfile = (c->format().profile() == QSurfaceFormat::CoreProfile);
95
96 // Load a pregenerated cache if the font contains one
97 loadPregeneratedCache(font);
98}
99
100QSGOpenGLDistanceFieldGlyphCache::~QSGOpenGLDistanceFieldGlyphCache()
101{
102 for (int i = 0; i < m_textures.count(); ++i)
103 m_funcs->glDeleteTextures(1, &m_textures[i].texture);
104
105 if (m_fboGuard != nullptr)
106 m_fboGuard->free();
107
108 delete m_blitProgram;
109 delete m_areaAllocator;
110}
111
112void QSGOpenGLDistanceFieldGlyphCache::requestGlyphs(const QSet<glyph_t> &glyphs)
113{
114 QList<GlyphPosition> glyphPositions;
115 QVector<glyph_t> glyphsToRender;
116
117 const int padding = QSG_OPENGL_DISTANCEFIELD_GLYPH_CACHE_PADDING;
118 const qreal scaleFactor = qreal(1) / QT_DISTANCEFIELD_SCALE(m_doubleGlyphResolution);
119
120 if (m_maxTextureHeight == 0) {
121 m_funcs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureWidth);
122
123 // We need to add a buffer to avoid glyphs that overlap the border between two
124 // textures causing the height of the textures to extend beyond the limit.
125 m_maxTextureHeight = m_maxTextureWidth - (qCeil(m_referenceFont.pixelSize() * scaleFactor) + distanceFieldRadius() * 2 + padding * 2);
126 }
127
128 if (m_areaAllocator == nullptr)
129 m_areaAllocator = new QSGAreaAllocator(QSize(m_maxTextureWidth, m_maxTextureCount * m_maxTextureHeight));
130
131 for (QSet<glyph_t>::const_iterator it = glyphs.constBegin(); it != glyphs.constEnd() ; ++it) {
132 glyph_t glyphIndex = *it;
133
134 QRectF boundingRect = glyphData(glyphIndex).boundingRect;
135 int glyphWidth = qCeil(boundingRect.width()) + distanceFieldRadius() * 2;
136 int glyphHeight = qCeil(boundingRect.height()) + distanceFieldRadius() * 2;
137 QSize glyphSize(glyphWidth + padding * 2, glyphHeight + padding * 2);
138 QRect alloc = m_areaAllocator->allocate(glyphSize);
139
140 if (alloc.isNull()) {
141 // Unallocate unused glyphs until we can allocated the new glyph
142 while (alloc.isNull() && !m_unusedGlyphs.isEmpty()) {
143 glyph_t unusedGlyph = *m_unusedGlyphs.constBegin();
144
145 TexCoord unusedCoord = glyphTexCoord(unusedGlyph);
146 QRectF unusedGlyphBoundingRect = glyphData(unusedGlyph).boundingRect;
147 int unusedGlyphWidth = qCeil(unusedGlyphBoundingRect.width()) + distanceFieldRadius() * 2;
148 int unusedGlyphHeight = qCeil(unusedGlyphBoundingRect.height()) + distanceFieldRadius() * 2;
149 m_areaAllocator->deallocate(QRect(unusedCoord.x - padding,
150 unusedCoord.y - padding,
151 padding * 2 + unusedGlyphWidth,
152 padding * 2 + unusedGlyphHeight));
153
154 m_unusedGlyphs.remove(unusedGlyph);
155 m_glyphsTexture.remove(unusedGlyph);
156 removeGlyph(unusedGlyph);
157
158 alloc = m_areaAllocator->allocate(glyphSize);
159 }
160
161 // Not enough space left for this glyph... skip to the next one
162 if (alloc.isNull())
163 continue;
164 }
165
166 TextureInfo *tex = textureInfo(alloc.y() / m_maxTextureHeight);
167 alloc = QRect(alloc.x(), alloc.y() % m_maxTextureHeight, alloc.width(), alloc.height());
168
169 tex->allocatedArea |= alloc;
170 Q_ASSERT(tex->padding == padding || tex->padding < 0);
171 tex->padding = padding;
172
173 GlyphPosition p;
174 p.glyph = glyphIndex;
175 p.position = alloc.topLeft() + QPoint(padding, padding);
176
177 glyphPositions.append(p);
178 glyphsToRender.append(glyphIndex);
179 m_glyphsTexture.insert(glyphIndex, tex);
180 }
181
182 setGlyphsPosition(glyphPositions);
183 markGlyphsToRender(glyphsToRender);
184}
185
186void QSGOpenGLDistanceFieldGlyphCache::storeGlyphs(const QList<QDistanceField> &glyphs)
187{
188 typedef QHash<TextureInfo *, QVector<glyph_t> > GlyphTextureHash;
189 typedef GlyphTextureHash::const_iterator GlyphTextureHashConstIt;
190
191 GlyphTextureHash glyphTextures;
192
193 GLint alignment = 4; // default value
194 m_funcs->glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
195
196 // Distance field data is always tightly packed
197 m_funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
198
199 for (int i = 0; i < glyphs.size(); ++i) {
200 QDistanceField glyph = glyphs.at(i);
201 glyph_t glyphIndex = glyph.glyph();
202 TexCoord c = glyphTexCoord(glyphIndex);
203 TextureInfo *texInfo = m_glyphsTexture.value(glyphIndex);
204
205 resizeTexture(texInfo, texInfo->allocatedArea.width(), texInfo->allocatedArea.height());
206 m_funcs->glBindTexture(GL_TEXTURE_2D, texInfo->texture);
207
208 glyphTextures[texInfo].append(glyphIndex);
209
210 int padding = texInfo->padding;
211 int expectedWidth = qCeil(c.width + c.xMargin * 2);
212 glyph = glyph.copy(-padding, -padding,
213 expectedWidth + padding * 2, glyph.height() + padding * 2);
214
215 if (useTextureResizeWorkaround()) {
216 uchar *inBits = glyph.scanLine(0);
217 uchar *outBits = texInfo->image.scanLine(int(c.y) - padding) + int(c.x) - padding;
218 for (int y = 0; y < glyph.height(); ++y) {
219 memcpy(outBits, inBits, glyph.width());
220 inBits += glyph.width();
221 outBits += texInfo->image.width();
222 }
223 }
224
225#if !defined(QT_OPENGL_ES_2)
226 const GLenum format = isCoreProfile() ? GL_RED : GL_ALPHA;
227#else
228 const GLenum format = GL_ALPHA;
229#endif
230 if (useTextureUploadWorkaround()) {
231 for (int i = 0; i < glyph.height(); ++i) {
232 m_funcs->glTexSubImage2D(GL_TEXTURE_2D, 0,
233 c.x - padding, c.y + i - padding, glyph.width(),1,
234 format, GL_UNSIGNED_BYTE,
235 glyph.scanLine(i));
236 }
237 } else {
238 m_funcs->glTexSubImage2D(GL_TEXTURE_2D, 0,
239 c.x - padding, c.y - padding, glyph.width(), glyph.height(),
240 format, GL_UNSIGNED_BYTE,
241 glyph.constBits());
242 }
243 }
244
245 // restore to previous alignment
246 m_funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
247
248 for (GlyphTextureHashConstIt i = glyphTextures.constBegin(), cend = glyphTextures.constEnd(); i != cend; ++i) {
249 Texture t;
250 t.textureId = i.key()->texture;
251 t.size = i.key()->size;
252 t.rhiBased = false;
253 setGlyphsTexture(i.value(), t);
254 }
255}
256
257void QSGOpenGLDistanceFieldGlyphCache::referenceGlyphs(const QSet<glyph_t> &glyphs)
258{
259 m_unusedGlyphs -= glyphs;
260}
261
262void QSGOpenGLDistanceFieldGlyphCache::releaseGlyphs(const QSet<glyph_t> &glyphs)
263{
264 m_unusedGlyphs += glyphs;
265}
266
267void QSGOpenGLDistanceFieldGlyphCache::createTexture(TextureInfo *texInfo,
268 int width,
269 int height)
270{
271 QByteArray zeroBuf(width * height, 0);
272 createTexture(texInfo, width, height, zeroBuf.constData());
273}
274
275void QSGOpenGLDistanceFieldGlyphCache::createTexture(TextureInfo *texInfo,
276 int width,
277 int height,
278 const void *pixels)
279{
280 if (useTextureResizeWorkaround() && texInfo->image.isNull()) {
281 texInfo->image = QDistanceField(width, height);
282 memcpy(texInfo->image.bits(), pixels, width * height);
283 }
284
285 while (m_funcs->glGetError() != GL_NO_ERROR) { }
286
287 m_funcs->glGenTextures(1, &texInfo->texture);
288 m_funcs->glBindTexture(GL_TEXTURE_2D, texInfo->texture);
289
290 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
291 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
292 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
293 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
294#if !defined(QT_OPENGL_ES_2)
295 if (!QOpenGLContext::currentContext()->isOpenGLES())
296 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
297 const GLint internalFormat = isCoreProfile() ? GL_R8 : GL_ALPHA;
298 const GLenum format = isCoreProfile() ? GL_RED : GL_ALPHA;
299#else
300 const GLint internalFormat = GL_ALPHA;
301 const GLenum format = GL_ALPHA;
302#endif
303
304 m_funcs->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, pixels);
305
306 texInfo->size = QSize(width, height);
307
308 GLuint error = m_funcs->glGetError();
309 if (error != GL_NO_ERROR) {
310 m_funcs->glBindTexture(GL_TEXTURE_2D, 0);
311 m_funcs->glDeleteTextures(1, &texInfo->texture);
312 texInfo->texture = 0;
313 }
314
315}
316
317static void freeFramebufferFunc(QOpenGLFunctions *funcs, GLuint id)
318{
319 funcs->glDeleteFramebuffers(1, &id);
320}
321
322void QSGOpenGLDistanceFieldGlyphCache::resizeTexture(TextureInfo *texInfo, int width, int height)
323{
324 QOpenGLContext *ctx = QOpenGLContext::currentContext();
325 Q_ASSERT(ctx);
326
327 int oldWidth = texInfo->size.width();
328 int oldHeight = texInfo->size.height();
329 if (width == oldWidth && height == oldHeight)
330 return;
331
332 GLuint oldTexture = texInfo->texture;
333 createTexture(texInfo, width, height);
334
335 if (!oldTexture)
336 return;
337
338 updateTexture(oldTexture, texInfo->texture, texInfo->size);
339
340#if !defined(QT_OPENGL_ES_2)
341 if (isCoreProfile() && !useTextureResizeWorkaround()) {
342 // For an OpenGL Core Profile we can use http://www.opengl.org/wiki/Framebuffer#Blitting
343 // to efficiently copy the contents of the old texture to the new texture
344 // TODO: Use ARB_copy_image if available of if we have >=4.3 context
345 if (!m_coreFuncs) {
346 m_coreFuncs = ctx->versionFunctions<QOpenGLFunctions_3_2_Core>();
347 Q_ASSERT(m_coreFuncs);
348 m_coreFuncs->initializeOpenGLFunctions();
349 }
350
351 // Create a framebuffer object to which we can attach our old and new textures (to
352 // the first two color buffer attachment points)
353 if (!m_fboGuard) {
354 GLuint fbo;
355 m_coreFuncs->glGenFramebuffers(1, &fbo);
356 m_fboGuard = new QOpenGLSharedResourceGuard(ctx, fbo, freeFramebufferFunc);
357 }
358
359 // Bind the FBO to both the GL_READ_FRAMEBUFFER? and GL_DRAW_FRAMEBUFFER targets
360 m_coreFuncs->glBindFramebuffer(GL_FRAMEBUFFER, m_fboGuard->id());
361
362 // Bind the old texture to GL_COLOR_ATTACHMENT0
363 m_coreFuncs->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
364 GL_TEXTURE_2D, oldTexture, 0);
365
366 // Bind the new texture to GL_COLOR_ATTACHMENT1
367 m_coreFuncs->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
368 GL_TEXTURE_2D, texInfo->texture, 0);
369
370 // Set the source and destination buffers
371 m_coreFuncs->glReadBuffer(GL_COLOR_ATTACHMENT0);
372 m_coreFuncs->glDrawBuffer(GL_COLOR_ATTACHMENT1);
373
374 // Do the blit
375 m_coreFuncs->glBlitFramebuffer(0, 0, oldWidth, oldHeight,
376 0, 0, oldWidth, oldHeight,
377 GL_COLOR_BUFFER_BIT, GL_NEAREST);
378
379 // Reset the default framebuffer
380 QOpenGLFramebufferObject::bindDefault();
381
382 return;
383 } else if (useTextureResizeWorkaround()) {
384#else
385 if (useTextureResizeWorkaround()) {
386#endif
387 GLint alignment = 4; // default value
388 m_funcs->glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
389 m_funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
390
391#if !defined(QT_OPENGL_ES_2)
392 const GLenum format = isCoreProfile() ? GL_RED : GL_ALPHA;
393#else
394 const GLenum format = GL_ALPHA;
395#endif
396
397 if (useTextureUploadWorkaround()) {
398 for (int i = 0; i < texInfo->image.height(); ++i) {
399 m_funcs->glTexSubImage2D(GL_TEXTURE_2D, 0,
400 0, i, oldWidth, 1,
401 format, GL_UNSIGNED_BYTE,
402 texInfo->image.scanLine(i));
403 }
404 } else {
405 m_funcs->glTexSubImage2D(GL_TEXTURE_2D, 0,
406 0, 0, oldWidth, oldHeight,
407 format, GL_UNSIGNED_BYTE,
408 texInfo->image.constBits());
409 }
410
411 m_funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, alignment); // restore to previous value
412
413 texInfo->image = texInfo->image.copy(0, 0, width, height);
414 m_funcs->glDeleteTextures(1, &oldTexture);
415 return;
416 }
417
418 if (!m_blitProgram)
419 createBlitProgram();
420
421 Q_ASSERT(m_blitProgram);
422
423 if (!m_fboGuard) {
424 GLuint fbo;
425 m_funcs->glGenFramebuffers(1, &fbo);
426 m_fboGuard = new QOpenGLSharedResourceGuard(ctx, fbo, freeFramebufferFunc);
427 }
428 m_funcs->glBindFramebuffer(GL_FRAMEBUFFER, m_fboGuard->id());
429
430 GLuint tmp_texture;
431 m_funcs->glGenTextures(1, &tmp_texture);
432 m_funcs->glBindTexture(GL_TEXTURE_2D, tmp_texture);
433 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
434 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
435 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
436 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
437#if !defined(QT_OPENGL_ES_2)
438 if (!ctx->isOpenGLES())
439 m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
440#endif
441 m_funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
442 GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
443 m_funcs->glBindTexture(GL_TEXTURE_2D, 0);
444 m_funcs->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
445 GL_TEXTURE_2D, tmp_texture, 0);
446
447 m_funcs->glActiveTexture(GL_TEXTURE0);
448 m_funcs->glBindTexture(GL_TEXTURE_2D, oldTexture);
449
450 // save current render states
451 GLboolean stencilTestEnabled;
452 GLboolean depthTestEnabled;
453 GLboolean scissorTestEnabled;
454 GLboolean blendEnabled;
455 GLint viewport[4];
456 GLint oldProgram;
457 m_funcs->glGetBooleanv(GL_STENCIL_TEST, &stencilTestEnabled);
458 m_funcs->glGetBooleanv(GL_DEPTH_TEST, &depthTestEnabled);
459 m_funcs->glGetBooleanv(GL_SCISSOR_TEST, &scissorTestEnabled);
460 m_funcs->glGetBooleanv(GL_BLEND, &blendEnabled);
461 m_funcs->glGetIntegerv(GL_VIEWPORT, &viewport[0]);
462 m_funcs->glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgram);
463
464 m_funcs->glDisable(GL_STENCIL_TEST);
465 m_funcs->glDisable(GL_DEPTH_TEST);
466 m_funcs->glDisable(GL_SCISSOR_TEST);
467 m_funcs->glDisable(GL_BLEND);
468
469 m_funcs->glViewport(0, 0, oldWidth, oldHeight);
470
471 const bool vaoInit = m_vao.isCreated();
472 if (isCoreProfile()) {
473 if ( !vaoInit )
474 m_vao.create();
475 m_vao.bind();
476 }
477 m_blitProgram->bind();
478 if (!vaoInit || !isCoreProfile()) {
479 m_blitBuffer.bind();
480
481 m_blitProgram->enableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
482 m_blitProgram->enableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
483 m_blitProgram->setAttributeBuffer(int(QT_VERTEX_COORDS_ATTR), GL_FLOAT, 0, 2);
484 m_blitProgram->setAttributeBuffer(int(QT_TEXTURE_COORDS_ATTR), GL_FLOAT, 32, 2);
485 }
486 m_blitProgram->disableAttributeArray(int(QT_OPACITY_ATTR));
487 m_blitProgram->setUniformValue("imageTexture", GLuint(0));
488
489 m_funcs->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
490
491 m_funcs->glBindTexture(GL_TEXTURE_2D, texInfo->texture);
492
493 if (useTextureUploadWorkaround()) {
494 for (int i = 0; i < oldHeight; ++i)
495 m_funcs->glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, i, 0, i, oldWidth, 1);
496 } else {
497 m_funcs->glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
498 }
499
500 m_funcs->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
501 GL_RENDERBUFFER, 0);
502 m_funcs->glDeleteTextures(1, &tmp_texture);
503 m_funcs->glDeleteTextures(1, &oldTexture);
504
505 QOpenGLFramebufferObject::bindDefault();
506
507 // restore render states
508 if (stencilTestEnabled)
509 m_funcs->glEnable(GL_STENCIL_TEST);
510 if (depthTestEnabled)
511 m_funcs->glEnable(GL_DEPTH_TEST);
512 if (scissorTestEnabled)
513 m_funcs->glEnable(GL_SCISSOR_TEST);
514 if (blendEnabled)
515 m_funcs->glEnable(GL_BLEND);
516 m_funcs->glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
517 m_funcs->glUseProgram(oldProgram);
518
519 m_blitProgram->disableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
520 m_blitProgram->disableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
521 if (isCoreProfile())
522 m_vao.release();
523}
524
525bool QSGOpenGLDistanceFieldGlyphCache::useTextureResizeWorkaround() const
526{
527 static bool set = false;
528 static bool useWorkaround = false;
529 if (!set) {
530 QOpenGLContextPrivate *ctx_p = static_cast<QOpenGLContextPrivate *>(QOpenGLContextPrivate::get(QOpenGLContext::currentContext()));
531 useWorkaround = ctx_p->workaround_brokenFBOReadBack
532 || qmlUseGlyphCacheWorkaround(); // on some hardware the workaround is faster (see QTBUG-29264)
533 set = true;
534 }
535 return useWorkaround;
536}
537
538bool QSGOpenGLDistanceFieldGlyphCache::useTextureUploadWorkaround() const
539{
540 static bool set = false;
541 static bool useWorkaround = false;
542 if (!set) {
543 useWorkaround = qstrcmp(reinterpret_cast<const char*>(m_funcs->glGetString(GL_RENDERER)),
544 "Mali-400 MP") == 0;
545 set = true;
546 }
547 return useWorkaround;
548}
549
550bool QSGOpenGLDistanceFieldGlyphCache::createFullSizeTextures() const
551{
552 return qsgPreferFullSizeGlyphCacheTextures() && glyphCount() > QT_DISTANCEFIELD_HIGHGLYPHCOUNT();
553}
554
555namespace {
556 struct Qtdf {
557 // We need these structs to be tightly packed, but some compilers we use do not
558 // support #pragma pack(1), so we need to hardcode the offsets/sizes in the
559 // file format
560 enum TableSize {
561 HeaderSize = 14,
562 GlyphRecordSize = 46,
563 TextureRecordSize = 17
564 };
565
566 enum Offset {
567 // Header
568 majorVersion = 0,
569 minorVersion = 1,
570 pixelSize = 2,
571 textureSize = 4,
572 flags = 8,
573 headerPadding = 9,
574 numGlyphs = 10,
575
576 // Glyph record
577 glyphIndex = 0,
578 textureOffsetX = 4,
579 textureOffsetY = 8,
580 textureWidth = 12,
581 textureHeight = 16,
582 xMargin = 20,
583 yMargin = 24,
584 boundingRectX = 28,
585 boundingRectY = 32,
586 boundingRectWidth = 36,
587 boundingRectHeight = 40,
588 textureIndex = 44,
589
590 // Texture record
591 allocatedX = 0,
592 allocatedY = 4,
593 allocatedWidth = 8,
594 allocatedHeight = 12,
595 texturePadding = 16
596
597 };
598
599 template <typename T>
600 static inline T fetch(const char *data, Offset offset)
601 {
602 return qFromBigEndian<T>(data + int(offset));
603 }
604 };
605}
606
607bool QSGOpenGLDistanceFieldGlyphCache::loadPregeneratedCache(const QRawFont &font)
608{
609 // The pregenerated data must be loaded first, otherwise the area allocator
610 // will be wrong
611 if (m_areaAllocator != nullptr) {
612 qWarning("Font cache must be loaded before cache is used");
613 return false;
614 }
615
616 static QElapsedTimer timer;
617
618 bool profile = QSG_LOG_TIME_GLYPH().isDebugEnabled();
619 if (profile)
620 timer.start();
621
622 QByteArray qtdfTable = font.fontTable("qtdf");
623 if (qtdfTable.isEmpty())
624 return false;
625
626 typedef QHash<TextureInfo *, QVector<glyph_t> > GlyphTextureHash;
627
628 GlyphTextureHash glyphTextures;
629
630 if (uint(qtdfTable.size()) < Qtdf::HeaderSize) {
631 qWarning("Invalid qtdf table in font '%s'",
632 qPrintable(font.familyName()));
633 return false;
634 }
635
636 const char *qtdfTableStart = qtdfTable.constData();
637 const char *qtdfTableEnd = qtdfTableStart + qtdfTable.size();
638
639 int padding = 0;
640 int textureCount = 0;
641 {
642 quint8 majorVersion = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::majorVersion);
643 quint8 minorVersion = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::minorVersion);
644 if (majorVersion != 5 || minorVersion != 12) {
645 qWarning("Invalid version of qtdf table %d.%d in font '%s'",
646 majorVersion,
647 minorVersion,
648 qPrintable(font.familyName()));
649 return false;
650 }
651
652 qreal pixelSize = qreal(Qtdf::fetch<quint16>(qtdfTableStart, Qtdf::pixelSize));
653 m_maxTextureWidth = m_maxTextureHeight = Qtdf::fetch<quint32>(qtdfTableStart, Qtdf::textureSize);
654 m_doubleGlyphResolution = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::flags) == 1;
655 padding = Qtdf::fetch<quint8>(qtdfTableStart, Qtdf::headerPadding);
656
657 if (pixelSize <= 0.0) {
658 qWarning("Invalid pixel size in '%s'", qPrintable(font.familyName()));
659 return false;
660 }
661
662 if (m_maxTextureWidth <= 0) {
663 qWarning("Invalid texture size in '%s'", qPrintable(font.familyName()));
664 return false;
665 }
666
667 int systemMaxTextureSize;
668 m_funcs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &systemMaxTextureSize);
669
670 if (m_maxTextureWidth > systemMaxTextureSize) {
671 qWarning("System maximum texture size is %d. This is lower than the value in '%s', which is %d",
672 systemMaxTextureSize,
673 qPrintable(font.familyName()),
674 m_maxTextureWidth);
675 }
676
677 if (padding != QSG_OPENGL_DISTANCEFIELD_GLYPH_CACHE_PADDING) {
678 qWarning("Padding mismatch in '%s'. Font requires %d, but Qt is compiled with %d.",
679 qPrintable(font.familyName()),
680 padding,
681 QSG_OPENGL_DISTANCEFIELD_GLYPH_CACHE_PADDING);
682 }
683
684 m_referenceFont.setPixelSize(pixelSize);
685
686 quint32 glyphCount = Qtdf::fetch<quint32>(qtdfTableStart, Qtdf::numGlyphs);
687 m_unusedGlyphs.reserve(glyphCount);
688
689 const char *allocatorData = qtdfTableStart + Qtdf::HeaderSize;
690 {
691 m_areaAllocator = new QSGAreaAllocator(QSize(0, 0));
692 allocatorData = m_areaAllocator->deserialize(allocatorData, qtdfTableEnd - allocatorData);
693 if (allocatorData == nullptr)
694 return false;
695 }
696
697 if (m_areaAllocator->size().height() % m_maxTextureHeight != 0) {
698 qWarning("Area allocator size mismatch in '%s'", qPrintable(font.familyName()));
699 return false;
700 }
701
702 textureCount = m_areaAllocator->size().height() / m_maxTextureHeight;
703 m_maxTextureCount = qMax(m_maxTextureCount, textureCount);
704
705 const char *textureRecord = allocatorData;
706 for (int i = 0; i < textureCount; ++i, textureRecord += Qtdf::TextureRecordSize) {
707 if (textureRecord + Qtdf::TextureRecordSize > qtdfTableEnd) {
708 qWarning("qtdf table too small in font '%s'.",
709 qPrintable(font.familyName()));
710 return false;
711 }
712
713 TextureInfo *tex = textureInfo(i);
714 tex->allocatedArea.setX(Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedX));
715 tex->allocatedArea.setY(Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedY));
716 tex->allocatedArea.setWidth(Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedWidth));
717 tex->allocatedArea.setHeight(Qtdf::fetch<quint32>(textureRecord, Qtdf::allocatedHeight));
718 tex->padding = Qtdf::fetch<quint8>(textureRecord, Qtdf::texturePadding);
719 }
720
721 const char *glyphRecord = textureRecord;
722 for (quint32 i = 0; i < glyphCount; ++i, glyphRecord += Qtdf::GlyphRecordSize) {
723 if (glyphRecord + Qtdf::GlyphRecordSize > qtdfTableEnd) {
724 qWarning("qtdf table too small in font '%s'.",
725 qPrintable(font.familyName()));
726 return false;
727 }
728
729 glyph_t glyph = Qtdf::fetch<quint32>(glyphRecord, Qtdf::glyphIndex);
730 m_unusedGlyphs.insert(glyph);
731
732 GlyphData &glyphData = emptyData(glyph);
733
734#define FROM_FIXED_POINT(value) \
735(((qreal)value)/(qreal)65536)
736
737 glyphData.texCoord.x = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureOffsetX));
738 glyphData.texCoord.y = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureOffsetY));
739 glyphData.texCoord.width = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureWidth));
740 glyphData.texCoord.height = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::textureHeight));
741 glyphData.texCoord.xMargin = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::xMargin));
742 glyphData.texCoord.yMargin = FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::yMargin));
743 glyphData.boundingRect.setX(FROM_FIXED_POINT(Qtdf::fetch<qint32>(glyphRecord, Qtdf::boundingRectX)));
744 glyphData.boundingRect.setY(FROM_FIXED_POINT(Qtdf::fetch<qint32>(glyphRecord, Qtdf::boundingRectY)));
745 glyphData.boundingRect.setWidth(FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::boundingRectWidth)));
746 glyphData.boundingRect.setHeight(FROM_FIXED_POINT(Qtdf::fetch<quint32>(glyphRecord, Qtdf::boundingRectHeight)));
747
748#undef FROM_FIXED_POINT
749
750 int textureIndex = Qtdf::fetch<quint16>(glyphRecord, Qtdf::textureIndex);
751 if (textureIndex < 0 || textureIndex >= textureCount) {
752 qWarning("Invalid texture index %d (texture count == %d) in '%s'",
753 textureIndex,
754 textureCount,
755 qPrintable(font.familyName()));
756 return false;
757 }
758
759
760 TextureInfo *texInfo = textureInfo(textureIndex);
761 m_glyphsTexture.insert(glyph, texInfo);
762
763 glyphTextures[texInfo].append(glyph);
764 }
765
766 GLint alignment = 4; // default value
767 m_funcs->glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
768
769 m_funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
770
771 const uchar *textureData = reinterpret_cast<const uchar *>(glyphRecord);
772 for (int i = 0; i < textureCount; ++i) {
773
774 TextureInfo *texInfo = textureInfo(i);
775
776 int width = texInfo->allocatedArea.width();
777 int height = texInfo->allocatedArea.height();
778 qint64 size = width * height;
779 if (reinterpret_cast<const char *>(textureData + size) > qtdfTableEnd) {
780 qWarning("qtdf table too small in font '%s'.",
781 qPrintable(font.familyName()));
782 return false;
783 }
784
785 createTexture(texInfo, width, height, textureData);
786
787 QVector<glyph_t> glyphs = glyphTextures.value(texInfo);
788
789 Texture t;
790 t.textureId = texInfo->texture;
791 t.size = texInfo->size;
792 t.rhiBased = false;
793
794 setGlyphsTexture(glyphs, t);
795
796 textureData += size;
797 }
798
799 m_funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
800 }
801
802 if (profile) {
803 quint64 now = timer.elapsed();
804 qCDebug(QSG_LOG_TIME_GLYPH,
805 "distancefield: %d pre-generated glyphs loaded in %dms",
806 m_unusedGlyphs.size(),
807 (int) now);
808 }
809
810 return true;
811}
812
813QT_END_NAMESPACE
814